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

Merge branch 'LukeUsher/master'

This commit is contained in:
PatrickvL 2016-11-30 20:36:34 +01:00
parent 8322532863 fb28a1470e
commit f9f3fa4b86
17 changed files with 2094 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/CxbxKrnl/EmuKrnlHal.cpp
View File

@ -240,13 +240,7 @@ XBSYSAPI EXPORTNUM(49) VOID DECLSPEC_NORETURN xboxkrnl::HalReturnToFirmware
)
{
LOG_FUNC_ONE_ARG(Routine);
// Prevent the dashboard from rebooting due to unimplemented crypto routines
if ((uint32_t)Routine != 4) {
CxbxKrnlCleanup("Xbe has rebooted : HalReturnToFirmware(%d)", Routine);
}
LOG_UNIMPLEMENTED();
CxbxKrnlCleanup("Xbe has rebooted : HalReturnToFirmware(%d)", Routine);
}
// ******************************************************************

1
src/CxbxKrnl/EmuKrnlIo.cpp
View File

@ -85,7 +85,6 @@ XBSYSAPI EXPORTNUM(66) xboxkrnl::NTSTATUS NTAPI xboxkrnl::IoCreateFile
NTSTATUS ret = STATUS_SUCCESS;
// TODO: Try redirecting to NtCreateFile if this function ever is run into
CxbxKrnlCleanup("IoCreateFile not implemented");
LOG_UNIMPLEMENTED();
RETURN(ret);

18
src/CxbxKrnl/EmuKrnlKe.cpp
View File

@ -340,6 +340,24 @@ XBSYSAPI EXPORTNUM(143) xboxkrnl::LONG NTAPI xboxkrnl::KeSetBasePriorityThread
RETURN(1);
}
// ******************************************************************
// * 0x0096 - KeSetPriorityThread
// ******************************************************************
XBSYSAPI EXPORTNUM(148) xboxkrnl::BOOLEAN NTAPI xboxkrnl::KeSetPriorityThread
(
IN PKTHREAD Thread,
IN PVOID Priority
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG_OUT(Thread)
LOG_FUNC_ARG_OUT(Priority)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(1);
}
// ******************************************************************
// * 0x0095 - KeSetTimer

35
src/CxbxKrnl/EmuKrnlNt.cpp
View File

@ -2255,6 +2255,41 @@ XBSYSAPI EXPORTNUM(232) VOID NTAPI xboxkrnl::NtUserIoApcDispatcher
DbgPrintf("EmuKrnl (0x%X): NtUserIoApcDispatcher Completed\n", GetCurrentThreadId());
}
// ******************************************************************
// * 0x00E9 - NtWaitForSingleObject
// ******************************************************************
XBSYSAPI EXPORTNUM(233) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWaitForSingleObject
(
IN HANDLE Handle,
IN BOOLEAN Alertable,
IN PVOID Timeout
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Handle)
LOG_FUNC_ARG(Alertable)
LOG_FUNC_ARG(Timeout)
LOG_FUNC_END;
NTSTATUS ret;
if (IsEmuHandle(Handle))
{
ret = WAIT_FAILED;
EmuWarning("WaitFor EmuHandle not supported!");
}
else
{
ret = NtDll::NtWaitForSingleObject(Handle, Alertable, (NtDll::PLARGE_INTEGER)Timeout);
DbgPrintf("Finished waiting for 0x%.08X\n", Handle);
}
if (ret == WAIT_FAILED)
EmuWarning("NtWaitForSingleObject failed! (%s)", NtStatusToString(ret));
RETURN(ret);
}
// ******************************************************************
// * 0x00EA - NtWaitForSingleObjectEx
// ******************************************************************

20
src/CxbxKrnl/EmuX86.cpp
View File

@ -87,25 +87,13 @@ void EmuX86_Write32(uint32_t addr, uint32_t value)
DWORD* EmuX86_GetRegisterPointer(LPEXCEPTION_POINTERS e, Zydis::Register reg)
{
switch (reg) {
case Zydis::Register::AL:
case Zydis::Register::AH:
case Zydis::Register::AX:
case Zydis::Register::EAX:
case Zydis::Register::AL: case Zydis::Register::AH: case Zydis::Register::AX: case Zydis::Register::EAX:
return &e->ContextRecord->Eax;
case Zydis::Register::BL:
case Zydis::Register::BH:
case Zydis::Register::BX:
case Zydis::Register::EBX:
case Zydis::Register::BL: case Zydis::Register::BH: case Zydis::Register::BX: case Zydis::Register::EBX:
return &e->ContextRecord->Ebx;
case Zydis::Register::CL:
case Zydis::Register::CH:
case Zydis::Register::CX:
case Zydis::Register::ECX:
case Zydis::Register::CL: case Zydis::Register::CH: case Zydis::Register::CX: case Zydis::Register::ECX:
return &e->ContextRecord->Ecx;
case Zydis::Register::DL:
case Zydis::Register::DH:
case Zydis::Register::DX:
case Zydis::Register::EDX:
case Zydis::Register::DL: case Zydis::Register::DH: case Zydis::Register::DX: case Zydis::Register::EDX:
return &e->ContextRecord->Edx;
case Zydis::Register::EDI:
return &e->ContextRecord->Edi;

533
src/CxbxKrnl/EmuXapi.cpp
View File

@ -92,6 +92,53 @@ BOOL WINAPI XTL::EmuXFormatUtilityDrive()
RETURN(TRUE);
}
// ******************************************************************
// * func: EmuGetTimeZoneInformation
// ******************************************************************
DWORD WINAPI XTL::EmuGetTimeZoneInformation
(
OUT LPTIME_ZONE_INFORMATION lpTimeZoneInformation
)
{
LOG_FUNC_ONE_ARG_OUT(lpTimeZoneInformation);
DWORD dwRet = GetTimeZoneInformation(lpTimeZoneInformation);
RETURN(dwRet);
}
// ******************************************************************
// * func: EmuQueryPerformanceCounter
// ******************************************************************
BOOL WINAPI XTL::EmuQueryPerformanceCounter
(
PLARGE_INTEGER lpPerformanceCount
)
{
LOG_FUNC_ONE_ARG(lpPerformanceCount);
BOOL bRet = QueryPerformanceCounter(lpPerformanceCount);
// debug - 4x speed
//lpPerformanceCount->QuadPart *= 4;
RETURN(bRet);
}
// ******************************************************************
// * func: EmuQueryPerformanceFrequency
// ******************************************************************
BOOL WINAPI XTL::EmuQueryPerformanceFrequency
(
PLARGE_INTEGER lpFrequency
)
{
LOG_FUNC_ONE_ARG(lpFrequency);
BOOL bRet = QueryPerformanceFrequency(lpFrequency);
RETURN(bRet);
}
// ******************************************************************
// * func: EmuXMountUtilityDrive
@ -534,6 +581,230 @@ DWORD WINAPI XTL::EmuXInputSetState
}
// ******************************************************************
// * func: EmuSetThreadPriorityBoost
// ******************************************************************
BOOL WINAPI XTL::EmuSetThreadPriorityBoost
(
HANDLE hThread,
BOOL DisablePriorityBoost
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(hThread)
LOG_FUNC_ARG(DisablePriorityBoost)
LOG_FUNC_END;
BOOL bRet = SetThreadPriorityBoost(hThread, DisablePriorityBoost);
if(bRet == FALSE)
EmuWarning("SetThreadPriorityBoost Failed!");
RETURN(bRet);
}
// ******************************************************************
// * func: EmuSetThreadPriority
// ******************************************************************
BOOL WINAPI XTL::EmuSetThreadPriority
(
HANDLE hThread,
int nPriority
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(hThread)
LOG_FUNC_ARG(nPriority)
LOG_FUNC_END;
BOOL bRet = SetThreadPriority(hThread, nPriority);
if(bRet == FALSE)
EmuWarning("SetThreadPriority Failed!");
RETURN(bRet);
}
// ******************************************************************
// * func: EmuGetThreadPriority
// ******************************************************************
int WINAPI XTL::EmuGetThreadPriority
(
HANDLE hThread
)
{
LOG_FUNC_ONE_ARG(hThread);
int iRet = GetThreadPriority(hThread);
if(iRet == THREAD_PRIORITY_ERROR_RETURN)
EmuWarning("GetThreadPriority Failed!");
RETURN(iRet);
}
// ******************************************************************
// * func: EmuGetExitCodeThread
// ******************************************************************
BOOL WINAPI XTL::EmuGetExitCodeThread
(
HANDLE hThread,
LPDWORD lpExitCode
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(hThread)
LOG_FUNC_ARG(lpExitCode)
LOG_FUNC_END;
BOOL bRet = GetExitCodeThread(hThread, lpExitCode);
RETURN(bRet);
}
// ******************************************************************
// * func: EmuXapiThreadStartup
// ******************************************************************
VOID WINAPI XTL::EmuXapiThreadStartup
(
DWORD dwDummy1,
DWORD dwDummy2
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(dwDummy1)
LOG_FUNC_ARG(dwDummy2)
LOG_FUNC_END;
typedef int (__stdcall *pfDummyFunc)(DWORD dwDummy);
pfDummyFunc func = (pfDummyFunc)dwDummy1;
func(dwDummy2);
// TODO: Call thread notify routines ?
/*
__asm
{
push dwDummy2
call dwDummy1
}
*/
//_asm int 3;
}
// ******************************************************************
// * func: EmuXRegisterThreadNotifyRoutine
// ******************************************************************
VOID WINAPI XTL::EmuXRegisterThreadNotifyRoutine
(
PXTHREAD_NOTIFICATION pThreadNotification,
BOOL fRegister
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(pThreadNotification)
LOG_FUNC_ARG(fRegister)
LOG_FUNC_END;
if(fRegister)
{
// I honestly don't expect this to happen, but if it does...
if(g_iThreadNotificationCount >= 16)
CxbxKrnlCleanup("Too many thread notification routines installed\n"
"If you're reading this message than tell blueshogun you saw it!!!");
// Find an empty spot in the thread notification array
for(int i = 0; i < 16; i++)
{
// If we find one, then add it to the array, and break the loop so
// that we don't accidently register the same routine twice!
if(g_pfnThreadNotification[i] == NULL)
{
g_pfnThreadNotification[i] = pThreadNotification->pfnNotifyRoutine;
g_iThreadNotificationCount++;
break;
}
}
}
else
{
// Go through each routine and nullify the routine passed in.
for(int i = 0; i < 16; i++)
{
if(pThreadNotification->pfnNotifyRoutine == g_pfnThreadNotification[i])
{
g_pfnThreadNotification[i] = NULL;
g_iThreadNotificationCount--;
break;
}
}
}
}
// ******************************************************************
// * func: EmuQueueUserAPC
// ******************************************************************
DWORD WINAPI XTL::EmuQueueUserAPC
(
PAPCFUNC pfnAPC,
HANDLE hThread,
DWORD dwData
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(pfnAPC)
LOG_FUNC_ARG(hThread)
LOG_FUNC_ARG(dwData)
LOG_FUNC_END;
DWORD dwRet = 0;
// If necessary, we can just continue to emulate NtQueueApcThread (0xCE).
// I added this because NtQueueApcThread fails in Metal Slug 3.
HANDLE hApcThread = NULL;
if(!DuplicateHandle(GetCurrentProcess(),hThread,GetCurrentProcess(),&hApcThread,THREAD_SET_CONTEXT,FALSE,0))
EmuWarning("DuplicateHandle failed!");
dwRet = QueueUserAPC(pfnAPC, hApcThread, dwData);
if(!dwRet)
EmuWarning("QueueUserAPC failed!");
RETURN(dwRet);
}
// ******************************************************************
// * func: EmuGetOverlappedResult
// ******************************************************************
BOOL WINAPI XTL::EmuGetOverlappedResult
(
HANDLE hFile,
LPOVERLAPPED lpOverlapped,
LPDWORD lpNumberOfBytesTransferred,
BOOL bWait
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(hFile)
LOG_FUNC_ARG(lpOverlapped)
LOG_FUNC_ARG(lpNumberOfBytesTransferred)
LOG_FUNC_ARG(bWait)
LOG_FUNC_END;
BOOL bRet = GetOverlappedResult( hFile, lpOverlapped, lpNumberOfBytesTransferred, bWait );
// if(bWait)
// bRet = TRUE; // Sucker...
RETURN(bRet);
}
// ******************************************************************
// * func: EmuXLaunchNewImage
// ******************************************************************
@ -678,6 +949,176 @@ DWORD WINAPI XTL::EmuXGetLaunchInfo
RETURN(dwRet);
}
// ******************************************************************
// * func: EmuXSetProcessQuantumLength
// ******************************************************************
VOID WINAPI XTL::EmuXSetProcessQuantumLength
(
DWORD dwMilliseconds
)
{
LOG_FUNC_ONE_ARG(dwMilliseconds);
// TODO: Implement?
LOG_IGNORED();
}
// ******************************************************************
// * func: EmuXGetFileCacheSize
// ******************************************************************
DWORD WINAPI XTL::EmuXGetFileCacheSize()
{
LOG_FUNC();
// Return the default cache size for now.
// TODO: Save the file cache size if/when set.
DWORD dwRet = 64 * 1024;
RETURN(dwRet);
}
// ******************************************************************
// * func: EmuSignalObjectAndWait
// ******************************************************************
DWORD WINAPI XTL::EmuSignalObjectAndWait
(
HANDLE hObjectToSignal,
HANDLE hObjectToWaitOn,
DWORD dwMilliseconds,
BOOL bAlertable
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(hObjectToSignal)
LOG_FUNC_ARG(hObjectToWaitOn)
LOG_FUNC_ARG(dwMilliseconds)
LOG_FUNC_ARG(bAlertable)
LOG_FUNC_END;
DWORD dwRet = SignalObjectAndWait( hObjectToSignal, hObjectToWaitOn, dwMilliseconds, bAlertable );
RETURN(dwRet);
}
// ******************************************************************
// * func: EmuPulseEvent
// ******************************************************************
BOOL WINAPI XTL::EmuPulseEvent
(
HANDLE hEvent
)
{
LOG_FUNC_ONE_ARG(hEvent);
// TODO: This function might be a bit too high level. If it is,
// feel free to implement NtPulseEvent in EmuKrnl.cpp
BOOL bRet = PulseEvent( hEvent );
RETURN(bRet);
}
// ******************************************************************
// * func: timeSetEvent
// ******************************************************************
MMRESULT WINAPI XTL::EmutimeSetEvent
(
UINT uDelay,
UINT uResolution,
LPTIMECALLBACK fptc,
DWORD dwUser,
UINT fuEvent
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(uDelay)
LOG_FUNC_ARG(uResolution)
LOG_FUNC_ARG(fptc)
LOG_FUNC_ARG(dwUser)
LOG_FUNC_ARG(fuEvent)
LOG_FUNC_END;
MMRESULT Ret = timeSetEvent( uDelay, uResolution, fptc, (DWORD_PTR) dwUser, fuEvent );
RETURN(Ret);
}
// ******************************************************************
// * func: timeKillEvent
// ******************************************************************
MMRESULT WINAPI XTL::EmutimeKillEvent
(
UINT uTimerID
)
{
LOG_FUNC_ONE_ARG(uTimerID);
MMRESULT Ret = timeKillEvent( uTimerID );
RETURN(Ret);
}
// ******************************************************************
// * func: EmuRaiseException
// ******************************************************************
VOID WINAPI XTL::EmuRaiseException
(
DWORD dwExceptionCode, // exception code
DWORD dwExceptionFlags, // continuable exception flag
DWORD nNumberOfArguments, // number of arguments
CONST ULONG_PTR *lpArguments // array of arguments
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(dwExceptionCode)
LOG_FUNC_ARG(dwExceptionFlags)
LOG_FUNC_ARG(nNumberOfArguments)
LOG_FUNC_ARG(lpArguments)
LOG_FUNC_END;
// TODO: Implement or not?
// RaiseException(dwExceptionCode, dwExceptionFlags, nNumberOfArguments, (*(ULONG_PTR**) &lpArguments));
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * func: EmuGetFileAttributesA
// ******************************************************************
DWORD WINAPI XTL::EmuGetFileAttributesA
(
LPCSTR lpFileName // name of file or directory
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(lpFileName)
LOG_FUNC_END;
// Deus Ex...
// Shave off the D:\ and default to the current directory.
// TODO: Other directories (i.e. Utility)?
char* szBuffer = (char*) lpFileName;
if((szBuffer[0] == 'D' || szBuffer[0] == 'd') && szBuffer[1] == ':' || szBuffer[2] == '\\')
{
szBuffer += 3;
DbgPrintf("EmuXapi (0x%X): GetFileAttributesA Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", lpFileName);
DbgPrintf(" New:\"$XbePath\\%s\"\n", szBuffer);
}
DWORD dwRet = GetFileAttributesA(szBuffer);
if(FAILED(dwRet))
EmuWarning("GetFileAttributes(\"%s\") failed!", szBuffer);
RETURN(dwRet);
}
// ******************************************************************
// func: XMountMUA
// ******************************************************************
@ -700,6 +1141,98 @@ DWORD WINAPI XTL::EmuXMountMUA
RETURN(E_FAIL);
}
// ******************************************************************
// func: EmuCreateWaitableTimer
// ******************************************************************
HANDLE WINAPI XTL::EmuCreateWaitableTimerA
(
LPVOID lpTimerAttributes, // SD
BOOL bManualReset, // reset type
LPCSTR lpTimerName // object name
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(lpTimerAttributes)
LOG_FUNC_ARG(bManualReset)
LOG_FUNC_ARG(lpTimerName)
LOG_FUNC_END;
// For Xbox titles, this param should always be NULL.
if(lpTimerAttributes)
EmuWarning("lpTimerAttributes != NULL");
HANDLE hRet = CreateWaitableTimerA( NULL, bManualReset, lpTimerName );
RETURN(hRet);
}
// ******************************************************************
// func: EmuSetWaitableTimer
// ******************************************************************
BOOL WINAPI XTL::EmuSetWaitableTimer
(
HANDLE hTimer, // handle to timer
const LARGE_INTEGER *pDueTime, // timer due time
LONG lPeriod, // timer interval
PTIMERAPCROUTINE pfnCompletionRoutine, // completion routine
LPVOID lpArgToCompletionRoutine, // completion routine parameter
BOOL fResume // resume state
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(hTimer)
LOG_FUNC_ARG(pDueTime)
LOG_FUNC_ARG(lPeriod)
LOG_FUNC_ARG(pfnCompletionRoutine)
LOG_FUNC_ARG(lpArgToCompletionRoutine)
LOG_FUNC_ARG(fResume)
LOG_FUNC_END;
BOOL Ret = SetWaitableTimer( hTimer, pDueTime, lPeriod, pfnCompletionRoutine,
lpArgToCompletionRoutine, fResume );
if(!Ret)
EmuWarning("SetWaitableTimer failed!");
RETURN(Ret);
}
// ******************************************************************
// * func: EmuXMountAlternateTitle
// ******************************************************************
DWORD WINAPI XTL::EmuXMountAlternateTitle
(
LPCSTR lpRootPath,
DWORD dwAltTitleId,
PCHAR pchDrive
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(lpRootPath)
LOG_FUNC_ARG(dwAltTitleId)
LOG_FUNC_ARG(pchDrive)
LOG_FUNC_END;
// TODO: Anything?
LOG_UNIMPLEMENTED();
RETURN(ERROR_SUCCESS);
}
// ******************************************************************
// * func: EmuXUnmountAlternateTitle
// ******************************************************************
DWORD WINAPI XTL::EmuXUnmountAlternateTitle
(
CHAR chDrive
)
{
LOG_FUNC_ONE_ARG(chDrive);
LOG_UNIMPLEMENTED();
RETURN(ERROR_SUCCESS);
}
// ******************************************************************
// * func: EmuXGetDeviceEnumerationStatus
// ******************************************************************

431
src/CxbxKrnl/EmuXapi.h
View File

@ -330,6 +330,84 @@ LAUNCH_DATA, *PLAUNCH_DATA;
// ******************************************************************
BOOL WINAPI EmuXFormatUtilityDrive();
// ******************************************************************
// * func: EmuGetTimeZoneInformation
// ******************************************************************
DWORD WINAPI EmuGetTimeZoneInformation
(
OUT LPTIME_ZONE_INFORMATION lpTimeZoneInformation
);
// ******************************************************************
// * func: EmuRtlCreateHeap
// ******************************************************************
PVOID WINAPI EmuRtlCreateHeap
(
IN ULONG Flags,
IN PVOID Base OPTIONAL,
IN ULONG Reserve OPTIONAL,
IN ULONG Commit,
IN PVOID 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: EmuRtlReAllocateHeap
// ******************************************************************
PVOID WINAPI EmuRtlReAllocateHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem,
IN SIZE_T dwBytes
);
// ******************************************************************
// * func: EmuRtlSizeHeap
// ******************************************************************
SIZE_T WINAPI EmuRtlSizeHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem
);
// ******************************************************************
// * func: EmuQueryPerformanceCounter
// ******************************************************************
BOOL WINAPI EmuQueryPerformanceCounter
(
PLARGE_INTEGER lpPerformanceCount
);
// ******************************************************************
// * func: EmuQueryPerformanceCounter
// ******************************************************************
BOOL WINAPI EmuQueryPerformanceFrequency
(
PLARGE_INTEGER lpFrequency
);
// ******************************************************************
// * func: EmuXMountUtilityDrive
// ******************************************************************
@ -419,6 +497,114 @@ DWORD WINAPI EmuXInputSetState
IN OUT PXINPUT_FEEDBACK pFeedback
);
// ******************************************************************
// * func: EmuCreateMutex
// ******************************************************************
HANDLE WINAPI EmuCreateMutex
(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCSTR lpName
);
// ******************************************************************
// * func: EmuCloseHandle
// ******************************************************************
BOOL WINAPI EmuCloseHandle
(
HANDLE hObject
);
// ******************************************************************
// * func: EmuSetThreadPriority
// ******************************************************************
BOOL WINAPI EmuSetThreadPriority
(
HANDLE hThread,
int nPriority
);
// ******************************************************************
// * func: EmuGetThreadPriority
// ******************************************************************
int WINAPI EmuGetThreadPriority
(
HANDLE hThread
);
// ******************************************************************
// * func: EmuSetThreadPriorityBoost
// ******************************************************************
BOOL WINAPI EmuSetThreadPriorityBoost
(
HANDLE hThread,
BOOL DisablePriorityBoost
);
// ******************************************************************
// * func: EmuGetExitCodeThread
// ******************************************************************
BOOL WINAPI EmuGetExitCodeThread
(
HANDLE hThread,
LPDWORD lpExitCode
);
// ******************************************************************
// * func: EmuXapiThreadStartup
// ******************************************************************
VOID WINAPI EmuXapiThreadStartup
(
DWORD dwDummy1,
DWORD dwDummy2
);
/* Too High Level!
// ******************************************************************
// * func: XapiSetupPerTitleDriveLetters
// ******************************************************************
NTSTATUS CDECL XapiSetupPerTitleDriveLetters(DWORD dwTitleId, LPCWSTR wszTitleName);
*/
// ******************************************************************
// * func: EmuXRegisterThreadNotifyRoutine
// ******************************************************************
VOID WINAPI EmuXRegisterThreadNotifyRoutine
(
PXTHREAD_NOTIFICATION pThreadNotification,
BOOL fRegister
);
// ******************************************************************
// * func: EmuRtlDestroyHeap
// ******************************************************************
PVOID WINAPI EmuRtlDestroyHeap
(
IN HANDLE HeapHandle
);
// ******************************************************************
// * func: EmuQueueUserAPC
// ******************************************************************
DWORD WINAPI EmuQueueUserAPC
(
PAPCFUNC pfnAPC,
HANDLE hThread,
DWORD dwData
);
// ******************************************************************
// * func: EmuGetOverlappedResult
// ******************************************************************
BOOL WINAPI EmuGetOverlappedResult
(
HANDLE hFile,
LPOVERLAPPED lpOverlapped,
LPDWORD lpNumberOfBytesTransferred,
BOOL bWait
);
// ******************************************************************
// * func: EmuXLaunchNewImage
// ******************************************************************
@ -437,6 +623,115 @@ DWORD WINAPI EmuXGetLaunchInfo
PLAUNCH_DATA pLaunchData
);
// ******************************************************************
// * func: EmuXSetProcessQuantumLength
// ******************************************************************
VOID WINAPI EmuXSetProcessQuantumLength
(
DWORD dwMilliseconds
);
// ******************************************************************
// * func: EmuXGetFileCacheSize
// ******************************************************************
DWORD WINAPI EmuXGetFileCacheSize();
// ******************************************************************
// * func: EmuSignalObjectAndWait
// ******************************************************************
DWORD WINAPI EmuSignalObjectAndWait
(
HANDLE hObjectToSignal,
HANDLE hObjectToWaitOn,
DWORD dwMilliseconds,
BOOL bAlertable
);
// ******************************************************************
// * func: EmuPulseEvent
// ******************************************************************
BOOL WINAPI EmuPulseEvent( HANDLE hEvent );
// ******************************************************************
// * func: EmuCreateSemaphore
// ******************************************************************
HANDLE WINAPI EmuCreateSemaphore
(
LPVOID lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPSTR lpName
);
// ******************************************************************
// * func: EmuReleaseSemaphore
// ******************************************************************
BOOL WINAPI EmuReleaseSemaphore
(
HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lpPreviousCount
);
// ******************************************************************
// * func: timeSetEvent
// ******************************************************************
MMRESULT WINAPI EmutimeSetEvent
(
UINT uDelay,
UINT uResolution,
LPTIMECALLBACK fptc,
DWORD dwUser,
UINT fuEvent
);
// ******************************************************************
// * func: timeKillEvent
// ******************************************************************
MMRESULT WINAPI EmutimeKillEvent
(
UINT uTimerID
);
// ******************************************************************
// * func: EmuRaiseException
// ******************************************************************
VOID WINAPI EmuRaiseException
(
DWORD dwExceptionCode, // exception code
DWORD dwExceptionFlags, // continuable exception flag
DWORD nNumberOfArguments, // number of arguments
CONST ULONG_PTR *lpArguments // array of arguments
);
// ******************************************************************
// * func: EmuGetFileAttributesA
// ******************************************************************
DWORD WINAPI EmuGetFileAttributesA
(
LPCSTR lpFileName // name of file or directory
);
// ******************************************************************
// * func: EmuVirtualProtect
// ******************************************************************
BOOL WINAPI EmuVirtualProtect
(
LPVOID lpAddress, // region of committed pages
SIZE_T dwSize, // size of the region
DWORD flNewProtect, // desired access protection
PDWORD lpflOldProtect // old protection
);
// ******************************************************************
// * func: EmulstrcmpiW
// ******************************************************************
int WINAPI EmulstrcmpiW
(
LPCWSTR lpString1,
LPCWSTR lpString2
);
// ******************************************************************
// * func: EmuXMountMUA
// ******************************************************************
@ -458,11 +753,84 @@ DWORD WINAPI EmuXMountMURootA
);
// ******************************************************************
// * func: EmuCreateWaitableTimerA
// ******************************************************************
HANDLE WINAPI EmuCreateWaitableTimerA
(
LPVOID lpTimerAttributes, // SD
BOOL bManualReset, // reset type
LPCSTR lpTimerName // object name
);
// ******************************************************************
// * func: EmuSetWaitableTimer
// ******************************************************************
BOOL WINAPI EmuSetWaitableTimer
(
HANDLE hTimer, // handle to timer
const LARGE_INTEGER *pDueTime, // timer due time
LONG lPeriod, // timer interval
PTIMERAPCROUTINE pfnCompletionRoutine, // completion routine
LPVOID lpArgToCompletionRoutine, // completion routine parameter
BOOL fResume // resume state
);
// ******************************************************************
// * func: EmuXMountAlternateTitle
// ******************************************************************
DWORD WINAPI EmuXMountAlternateTitle
(
LPCSTR lpRootPath,
DWORD dwAltTitleId,
PCHAR pchDrive
);
// ******************************************************************
// * func: EmuXUnmountAlternateTitle
// ******************************************************************
DWORD WINAPI EmuXUnmountAlternateTitle(CHAR chDrive);
// ******************************************************************
// * func: EmuVirtualAlloc
// ******************************************************************
LPVOID WINAPI EmuVirtualAlloc
(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect
);
// ******************************************************************
// * func: EmuVirtualAlloc
// ******************************************************************
BOOL WINAPI EmuVirtualFree
(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD dwFreeType
);
// ******************************************************************
// * func: EmuMoveFileA
// ******************************************************************
BOOL WINAPI EmuMoveFileA
(
LPCSTR lpExistingFileName,
LPCSTR lpNewFileName
);
// ******************************************************************
// * func: EmuXGetDeviceEnumerationStatus
// ******************************************************************
DWORD WINAPI EmuXGetDeviceEnumerationStatus();
// ******************************************************************
// * func: EmuSwitchToThread
// ******************************************************************
BOOL WINAPI EmuSwitchToThread();
// ******************************************************************
// * func: EmuXInputGetDeviceDescription
// ******************************************************************
DWORD WINAPI EmuXInputGetDeviceDescription
@ -476,5 +844,68 @@ DWORD WINAPI EmuXInputGetDeviceDescription
// ******************************************************************
int WINAPI EmuXAutoPowerDownResetTimer();
// ******************************************************************
// * func: EmuReadFileEx
// ******************************************************************
BOOL WINAPI EmuReadFileEx
(
HANDLE hFile, // handle to file
LPVOID lpBuffer, // data buffer
DWORD nNumberOfBytesToRead, // number of bytes to read
LPOVERLAPPED lpOverlapped, // offset
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine // completion routine
);
// ******************************************************************
// * func: EmuWriteFileEx
// ******************************************************************
BOOL WINAPI EmuWriteFileEx
(
HANDLE hFile, // handle to output file
LPCVOID lpBuffer, // data buffer
DWORD nNumberOfBytesToWrite, // number of bytes to write
LPOVERLAPPED lpOverlapped, // overlapped buffer
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine // completion routine
);
// s+
/* not necessary?
// ******************************************************************
// * func: EmuXCalculateSignatureBegin
// ******************************************************************
HANDLE WINAPI EmuXCalculateSignatureBegin
(
DWORD dwFlags
);
// ******************************************************************
// * func: EmuXCalculateSignatureBegin
// ******************************************************************
HANDLE WINAPI EmuXCalculateSignatureBeginEx
(
DWORD dwFlags,
DWORD dwAltTitleId
);
// ******************************************************************
// * func: EmuXCalculateSignatureUpdate
// ******************************************************************
DWORD WINAPI EmuXCalculateSignatureUpdate
(
HANDLE hCalcSig,
const BYTE *pbData,
ULONG cbData
);
// ******************************************************************
// * func: EmuXCalculateSignatureEnd
// ******************************************************************
DWORD WINAPI EmuXCalculateSignatureEnd
(
HANDLE hCalcSig,
PXCALCSIG_SIGNATURE pSignature
);
//*/
// +s
#endif

205
src/CxbxKrnl/HLEDataBase/Xapi.1.0.3911.inl
View File

@ -1590,6 +1590,16 @@ SOOVPA<8> WriteFileEx_1_0_3911 =
// ******************************************************************
OOVPATable XAPI_1_0_3911[] =
{
// GetExitCodeThread
{
(OOVPA*)&GetExitCodeThread_1_0_3911,
XTL::EmuGetExitCodeThread,
#ifdef _DEBUG_TRACE
"EmuGetExitCodeThread"
#endif
},
//*/
// XInitDevices
{
@ -1601,6 +1611,60 @@ OOVPATable XAPI_1_0_3911[] =
"EmuXInitDevices"
#endif
},
/* Too High Level
// CreateMutex
{
(OOVPA*)&CreateMutex_1_0_3911,
XTL::EmuCreateMutex,
#ifdef _DEBUG_TRACE
"EmuCreateMutex"
#endif
},
//*/
/* Too High Level */
// CreateThread
/* {
(OOVPA*)&CreateThread_1_0_3911,
XTL::EmuCreateThread,
#ifdef _DEBUG_TRACE
"EmuCreateThread"
#endif
},*/
// SetThreadPriority
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
//*/
// GetTimeZoneInformation
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// XRegisterThreadNotifyRoutine
{
(OOVPA*)&XRegisterThreadNotifyRoutine_1_0_3911,
XTL::EmuXRegisterThreadNotifyRoutine,
#ifdef _DEBUG_TRACE
"EmuXRegisterThreadNotifyRoutine"
#endif
},
/*
// XCalculateSignatureBegin
{
@ -1691,6 +1755,26 @@ OOVPATable XAPI_1_0_3911[] =
"EmuXInputSetState"
#endif
},
// SetThreadPriorityBoost
{
(OOVPA*)&SetThreadPriorityBoost_1_0_3911,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriorityBoost"
#endif
},
// GetThreadPriority
{
(OOVPA*)&GetThreadPriority_1_0_3911,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuGetThreadPriority"
#endif
},
// XGetDevices
{
(OOVPA*)&XGetDevices_1_0_3911,
@ -1711,6 +1795,64 @@ OOVPATable XAPI_1_0_3911[] =
"EmuXInputGetCapabilities"
#endif
},
// SignalObjectAndWait
{
(OOVPA*)&SignalObjectAndWait_1_0_3911,
XTL::EmuSignalObjectAndWait,
#ifdef _DEBUG_TRACE
"EmuSignalObjectAndWait"
#endif
},
// PulseEvent
{
(OOVPA*)&PulseEvent_1_0_3911,
XTL::EmuPulseEvent,
#ifdef _DEBUG_TRACE
"EmuPulseEvent"
#endif
},
// QueueUserAPC
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// lstrcmpiW
/*{
(OOVPA*)&lstrcmpiW_1_0_3911,
XTL::EmulstrcmpiW,
#ifdef _DEBUG_TRACE
"EmulstrcmpiW"
#endif
},*/
// XMountAlternateTitleA
{
(OOVPA*)&XMountAlternateTitleA_1_0_3911,
XTL::EmuXMountAlternateTitle,
#ifdef _DEBUG_TRACE
"XMountAlternateTitleA"
#endif
},
// XUnmountAlternateTitleA
{
(OOVPA*)&XUnmountAlternateTitleA_1_0_3911,
XTL::EmuXUnmountAlternateTitle,
#ifdef _DEBUG_TRACE
"XUnmountAlternateTitleA"
#endif
},
// XMountMUA
{
(OOVPA*)&XMountMUA_1_0_3911,
@ -1767,6 +1909,69 @@ OOVPATable XAPI_1_0_3911[] =
"EmuXMountUtilityDrive"
#endif
},
// GetFileAttributesA
{
(OOVPA*)&GetFileAttributesA_1_0_3911,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"EmuGetFileAttributesA"
#endif
},
// ReadFileEx
/*{
(OOVPA*)&ReadFileEx_1_0_3911,
XTL::EmuReadFileEx,
#ifdef _DEBUG_TRACE
"EmuReadFileEx"
#endif
},
// WriteFileEx
{
(OOVPA*)&WriteFileEx_1_0_3911,
XTL::EmuWriteFileEx,
#ifdef _DEBUG_TRACE
"EmuWriteFileEx"
#endif
},*/
// CloseHandle
/*{
(OOVPA*)&CloseHandle_1_0_3911,
XTL::EmuCloseHandle,
#ifdef _DEBUG_TRACE
"CloseHandle"
#endif
},*/
// ExitThread
/*{
(OOVPA*)&ExitThread_1_0_3911,
XTL::EmuExitThread,
#ifdef _DEBUG_TRACE
"ExitThread"
#endif
},*/
// VirtualAlloc@16
//{
// (OOVPA*)&VirtualAlloc_1_0_3911,
// XTL::EmuVirtualAlloc,
// #ifdef _DEBUG_TRACE
// "EmuVirtualAlloc"
// #endif
//},
//// VirtualFree@12
//{
// (OOVPA*)&VirtualFree_1_0_3911,
// XTL::EmuVirtualFree,
// #ifdef _DEBUG_TRACE
// "EmuVirtualFree"
// #endif
//},
};
// ******************************************************************

86
src/CxbxKrnl/HLEDataBase/Xapi.1.0.4034.inl
View File

@ -255,6 +255,71 @@ OOVPATable XAPI_1_0_4034[] =
#endif
},
*/
/* Too High Level
// CreateThread (* unchanged since 1.0.3911 *)
{
(OOVPA*)&CreateThread_1_0_3911,
XTL::EmuCreateThread,
#ifdef _DEBUG_TRACE
"EmuCreateThread"
#endif
},
*/
/*
// CloseHandle (*???*)
{
(OOVPA*)&CloseHandle_1_0_(???),
XTL::EmuCloseHandle,
#ifdef _DEBUG_TRACE
"EmuCloseHandle"
#endif
},
*/
//*/
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// SignalObjectAndWait (* unchanged since 3911 *)
{
(OOVPA*)&SignalObjectAndWait_1_0_3911,
XTL::EmuSignalObjectAndWait,
#ifdef _DEBUG_TRACE
"EmuSignalObjectAndWait"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// XInputSetState (* unchanged since 3911 *)
{
(OOVPA*)&XInputSetState_1_0_3911,
@ -265,6 +330,17 @@ OOVPATable XAPI_1_0_4034[] =
"EmuXInputSetState"
#endif
},
// XRegisterThreadNotifyRoutine (* unchanged since 3911 *)
{
(OOVPA*)&XRegisterThreadNotifyRoutine_1_0_3911,
XTL::EmuXRegisterThreadNotifyRoutine,
#ifdef _DEBUG_TRACE
"EmuXRegisterThreadNotifyRoutine"
#endif
},
// XGetDeviceChanges (* unchanged since 3911 *)
{
(OOVPA*)&XGetDeviceChanges_1_0_3911,
@ -303,6 +379,16 @@ OOVPATable XAPI_1_0_4034[] =
"EmuXInputGetCapabilities"
#endif
},
// GetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&GetThreadPriority_1_0_3911,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuGetThreadPriority"
#endif
},
// XInputOpen (* unchanged since 3911 *)
{
(OOVPA*)&XInputOpen_1_0_3911,

128
src/CxbxKrnl/HLEDataBase/Xapi.1.0.4134.inl
View File

@ -406,6 +406,27 @@ OOVPATable XAPI_1_0_4134[] =
"EmuXInitDevices"
#endif
},
//*/
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// GetExitCodeThread (* unchanged since 3911 *)
{
(OOVPA*)&GetExitCodeThread_1_0_3911,
XTL::EmuGetExitCodeThread,
#ifdef _DEBUG_TRACE
"EmuGetExitCodeThread"
#endif
},
// XGetDevices
{
(OOVPA*)&XGetDevices_1_0_4134,
@ -455,6 +476,26 @@ OOVPATable XAPI_1_0_4134[] =
#ifdef _DEBUG_TRACE
"EmuXMountUtilityDrive"
#endif
},
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// XRegisterThreadNotifyRoutine (* unchanged since 3911 *)
{
(OOVPA*)&XRegisterThreadNotifyRoutine_1_0_3911,
XTL::EmuXRegisterThreadNotifyRoutine,
#ifdef _DEBUG_TRACE
"EmuXRegisterThreadNotifyRoutine"
#endif
},
// XGetDeviceChanges (* unchanged since 3911 *)
{
@ -493,6 +534,36 @@ OOVPATable XAPI_1_0_4134[] =
#ifdef _DEBUG_TRACE
"EmuXInputGetCapabilities"
#endif
},
// GetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&GetThreadPriority_1_0_3911,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuGetThreadPriority"
#endif
},
// QueryPerformanceCounter
{
(OOVPA*)&QueryPerformanceCounter_1_0_4134,
XTL::EmuQueryPerformanceCounter,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceCounter"
#endif
},
// QueryPerformanceFrequency
{
(OOVPA*)&QueryPerformanceFrequency_1_0_4134,
XTL::EmuQueryPerformanceFrequency,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceFrequency"
#endif
},
// XInputPoll
{
@ -504,6 +575,36 @@ OOVPATable XAPI_1_0_4134[] =
"EmuXInputPoll"
#endif
},
// SetThreadPriorityBoost (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriorityBoost_1_0_3911,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriorityBoost"
#endif
},
// SignalObjectAndWait (* unchanged since 3911 *)
{
(OOVPA*)&SignalObjectAndWait_1_0_3911,
XTL::EmuSignalObjectAndWait,
#ifdef _DEBUG_TRACE
"EmuSignalObjectAndWait"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// XMountMUA
{
(OOVPA*)&XMountMUA_1_0_4134,
@ -512,6 +613,33 @@ OOVPATable XAPI_1_0_4134[] =
#ifdef _DEBUG_TRACE
"EmuXMountMUA"
#endif
},
// GetFileAttributesA
{
(OOVPA*)&GetFileAttributesA_1_0_4134,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"EmuGetFileAttributesA"
#endif
},
// timeSetEvent
{
(OOVPA*)&timeSetEvent_1_0_4134,
XTL::EmutimeSetEvent,
#ifdef _DEBUG_TRACE
"EmutimeSetEvent"
#endif
},
// timeKillEvent
{
(OOVPA*)&timeKillEvent_1_0_4134,
XTL::EmutimeKillEvent,
#ifdef _DEBUG_TRACE
"EmutimeKillEvent"
#endif
},
// XLaunchNewImageA
{

108
src/CxbxKrnl/HLEDataBase/Xapi.1.0.4361.inl
View File

@ -589,6 +589,27 @@ SOOVPA<7> SetWaitableTimer_1_0_4361 =
// ******************************************************************
OOVPATable XAPI_1_0_4361[] =
{
// QueryPerformanceCounter
{
(OOVPA*)&QueryPerformanceCounter_1_0_4361,
XTL::EmuQueryPerformanceCounter,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceCounter"
#endif
},
// QueryPerformanceFrequency
{
(OOVPA*)&QueryPerformanceFrequency_1_0_4361,
XTL::EmuQueryPerformanceFrequency,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceFrequency"
#endif
},
// XInitDevices (* unchanged since 1.0.3911 *)
{
(OOVPA*)&XInitDevices_1_0_3911,
@ -700,6 +721,75 @@ OOVPATable XAPI_1_0_4361[] =
#ifdef _DEBUG_TRACE
"EmuXMountUtilityDrive_4242"
#endif
},
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// GetExitCodeThread (* unchanged since 3911 *)
{
(OOVPA*)&GetExitCodeThread_1_0_3911,
XTL::EmuGetExitCodeThread,
#ifdef _DEBUG_TRACE
"EmuGetExitCodeThread"
#endif
},
// SetThreadPriorityBoost (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriorityBoost_1_0_3911,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriorityBoost"
#endif
},
// SignalObjectAndWait (* unchanged since 3911 *)
{
(OOVPA*)&SignalObjectAndWait_1_0_3911,
XTL::EmuSignalObjectAndWait,
#ifdef _DEBUG_TRACE
"EmuSignalObjectAndWait"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// GetFileAttributesA (* unchanged since 4134 *)
{
(OOVPA*)&GetFileAttributesA_1_0_4134,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"EmuGetFileAttributesA"
#endif
},
// XMountMUA
{
@ -710,6 +800,24 @@ OOVPATable XAPI_1_0_4361[] =
"EmuXMountMUA"
#endif
},
// CreateWaitableTimerA
{
(OOVPA*)&CreateWaitableTimerA_1_0_4361,
XTL::EmuCreateWaitableTimerA,
#ifdef _DEBUG_TRACE
"EmuCreateWaitableTimerA"
#endif
},
// SetWaitableTimer
{
(OOVPA*)&SetWaitableTimer_1_0_4361,
XTL::EmuSetWaitableTimer,
#ifdef _DEBUG_TRACE
"EmuSetWaitableTimer"
#endif
},
};
// ******************************************************************

78
src/CxbxKrnl/HLEDataBase/Xapi.1.0.4432.inl
View File

@ -199,6 +199,84 @@ OOVPATable XAPI_1_0_4432[] =
#endif
},
//*/
//*/
// GetExitCodeThread (* unchanged since 3911 *)
{
(OOVPA*)&GetExitCodeThread_1_0_3911,
XTL::EmuGetExitCodeThread,
#ifdef _DEBUG_TRACE
"EmuGetExitCodeThread"
#endif
},
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// SignalObjectAndWait (* unchanged since 3911 *)
{
(OOVPA*)&SignalObjectAndWait_1_0_3911,
XTL::EmuSignalObjectAndWait,
#ifdef _DEBUG_TRACE
"EmuSignalObjectAndWait"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// GetFileAttributesA (* unchanged since 4134 *)
{
(OOVPA*)&GetFileAttributesA_1_0_4134,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"EmuGetFileAttributesA"
#endif
},
// timeSetEvent
{
(OOVPA*)&timeSetEvent_1_0_4134,
XTL::EmutimeSetEvent,
#ifdef _DEBUG_TRACE
"EmutimeSetEvent"
#endif
},
// timeKillEvent
{
(OOVPA*)&timeKillEvent_1_0_4134,
XTL::EmutimeKillEvent,
#ifdef _DEBUG_TRACE
"EmutimeKillEvent"
#endif
},
// XLaunchNewImageA
{
(OOVPA*)&XLaunchNewImageA_1_0_3911,

191
src/CxbxKrnl/HLEDataBase/Xapi.1.0.4627.inl
View File

@ -1035,6 +1035,66 @@ OOVPATable XAPI_1_0_4627[] =
"EmuXFormatUtilityDrive"
#endif
},
// SetThreadPriorityBoost
{
(OOVPA*)&SetThreadPriorityBoost_1_0_4627,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriorityBoost"
#endif
},
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// GetThreadPriority
{
(OOVPA*)&GetThreadPriority_1_0_4627,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuGetThreadPriority"
#endif
},
// XRegisterThreadNotifyRoutine (* unchanged since 3911 *)
{
(OOVPA*)&XRegisterThreadNotifyRoutine_1_0_3911,
XTL::EmuXRegisterThreadNotifyRoutine,
#ifdef _DEBUG_TRACE
"EmuXRegisterThreadNotifyRoutine"
#endif
},
// QueryPerformanceCounter (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceCounter_1_0_4361,
XTL::EmuQueryPerformanceCounter,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceCounter"
#endif
},
// QueryPerformanceFrequency (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceFrequency_1_0_4361,
XTL::EmuQueryPerformanceFrequency,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceFrequency"
#endif
},
// XMountUtilityDrive (* unchanged since 4432 *)
{
(OOVPA*)&XMountUtilityDrive_1_0_4432,
@ -1327,6 +1387,36 @@ OOVPATable XAPI_1_0_4627[] =
#endif
},
//*/
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// GetExitCodeThread (* unchanged since 3911 *)
{
(OOVPA*)&GetExitCodeThread_1_0_3911,
XTL::EmuGetExitCodeThread,
#ifdef _DEBUG_TRACE
"EmuGetExitCodeThread"
#endif
},
// GetOverlappedResult
{
(OOVPA*)&GetOverlappedResult_1_0_4627,
XTL::EmuGetOverlappedResult,
#ifdef _DEBUG_TRACE
"EmuGetOverlappedResult"
#endif
},
// XLaunchNewImageA
{
(OOVPA*)&XLaunchNewImageA_1_0_4627,
@ -1354,6 +1444,107 @@ OOVPATable XAPI_1_0_4627[] =
"EmuXGetLaunchInfo"
#endif
},
// XSetProcessQuantumLength
{
(OOVPA*)&XSetProcessQuantumLength_1_0_4627,
XTL::EmuXSetProcessQuantumLength,
#ifdef _DEBUG_TRACE
"EmuXSetProcessQuantumLength"
#endif
},
// SignalObjectAndWait (* unchanged since 3911 *)
{
(OOVPA*)&SignalObjectAndWait_1_0_3911,
XTL::EmuSignalObjectAndWait,
#ifdef _DEBUG_TRACE
"EmuSignalObjectAndWait"
#endif
},
// timeSetEvent
{
(OOVPA*)&timeSetEvent_1_0_4627,
XTL::EmutimeSetEvent,
#ifdef _DEBUG_TRACE
"EmutimeSetEvent"
#endif
},
// timeKillEvent
{
(OOVPA*)&timeKillEvent_1_0_4627,
XTL::EmutimeKillEvent,
#ifdef _DEBUG_TRACE
"EmutimeKillEvent"
#endif
},
// RaiseException
{
(OOVPA*)&RaiseException_1_0_4627,
XTL::EmuRaiseException,
#ifdef _DEBUG_TRACE
"EmuRaiseException"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// XMountAlternateTitleA
{
(OOVPA*)&XMountAlternateTitleA_1_0_4627,
XTL::EmuXMountAlternateTitle,
#ifdef _DEBUG_TRACE
"XMountAlternateTitleA"
#endif
},
// XMountAlternateTitleA
{
(OOVPA*)&XMountAlternateTitleA_1_0_4928,
XTL::EmuXMountAlternateTitle,
#ifdef _DEBUG_TRACE
"XMountAlternateTitleA (4928)"
#endif
},
// XUnmountAlternateTitleA
{
(OOVPA*)&XUnmountAlternateTitleA_1_0_4627,
XTL::EmuXUnmountAlternateTitle,
#ifdef _DEBUG_TRACE
"XUnmountAlternateTitleA"
#endif
},
// GetFileAttributesA (* unchanged since 4134 *)
{
(OOVPA*)&GetFileAttributesA_1_0_4134,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"EmuGetFileAttributesA"
#endif
},
// XGetFileCacheSize
{
(OOVPA*)&XGetFileCacheSize_1_0_4627,
XTL::EmuXGetFileCacheSize,
#ifdef _DEBUG_TRACE
"XGetFileCacheSize"
#endif
},
// XInputGetDeviceDescription
{
(OOVPA*)&XInputGetDeviceDescription_1_0_4831,

99
src/CxbxKrnl/HLEDataBase/Xapi.1.0.5233.inl
View File

@ -151,6 +151,77 @@ SOOVPA<6> XGetFileCacheSize_1_0_5344 =
// ******************************************************************
OOVPATable XAPI_1_0_5233[] =
{
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// SetThreadPriorityBoost (* unchanged since 4627 *)
{
(OOVPA*)&SetThreadPriorityBoost_1_0_4627,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriorityBoost"
#endif
},
// GetThreadPriority (* unchanged since 4627 *)
{
(OOVPA*)&GetThreadPriority_1_0_4627,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuGetThreadPriority"
#endif
},
// XRegisterThreadNotifyRoutine (* unchanged since 3911 *)
{
(OOVPA*)&XRegisterThreadNotifyRoutine_1_0_3911,
XTL::EmuXRegisterThreadNotifyRoutine,
#ifdef _DEBUG_TRACE
"EmuXRegisterThreadNotifyRoutine"
#endif
},
// QueryPerformanceCounter (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceCounter_1_0_4361,
XTL::EmuQueryPerformanceCounter,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceCounter"
#endif
},
// QueryPerformanceFrequency (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceFrequency_1_0_4361,
XTL::EmuQueryPerformanceFrequency,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceFrequency"
#endif
},
// XMountUtilityDrive (* unchanged since 4432 *)
{
(OOVPA*)&XMountUtilityDrive_1_0_4432,
@ -249,6 +320,34 @@ OOVPATable XAPI_1_0_5233[] =
"EmuXInputSetState"
#endif
},
// XGetFileCacheSize
{
(OOVPA*)&XGetFileCacheSize_1_0_5344,
XTL::EmuXGetFileCacheSize,
#ifdef _DEBUG_TRACE
"XGetFileCacheSize"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// GetFileAttributesA (* unchanged since 4134 *)
{
(OOVPA*)&GetFileAttributesA_1_0_4134,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"EmuGetFileAttributesA"
#endif
},
};
// ******************************************************************

99
src/CxbxKrnl/HLEDataBase/Xapi.1.0.5558.inl
View File

@ -487,6 +487,46 @@ SOOVPA<9> XInputClose_1_0_5558 =
// ******************************************************************
OOVPATable XAPI_1_0_5558[] =
{
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// XRegisterThreadNotifyRoutine (* unchanged since 3911 *)
{
(OOVPA*)&XRegisterThreadNotifyRoutine_1_0_3911,
XTL::EmuXRegisterThreadNotifyRoutine,
#ifdef _DEBUG_TRACE
"EmuXRegisterThreadNotifyRoutine"
#endif
},
// QueryPerformanceCounter (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceCounter_1_0_4361,
XTL::EmuQueryPerformanceCounter,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceCounter"
#endif
},
// QueryPerformanceFrequency (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceFrequency_1_0_4361,
XTL::EmuQueryPerformanceFrequency,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceFrequency"
#endif
},
// XMountUtilityDrive (* unchanged since 4432 *)
{
(OOVPA*)&XMountUtilityDrive_1_0_4432,
@ -596,6 +636,65 @@ OOVPATable XAPI_1_0_5558[] =
#ifdef _DEBUG_TRACE
"XGetLaunchInfo"
#endif
},
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// GetFileAttributesA
{
(OOVPA*)&GetFileAttributesA_1_0_5558,
XTL::EmuGetFileAttributesA,
#ifdef _DEBUG_TRACE
"GetFileAttributesA"
#endif
},
// SetThreadPriorityBoost (* unchanged since 4627 *)
{
(OOVPA*)&SetThreadPriorityBoost_1_0_4627,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriorityBoost"
#endif
},
// GetThreadPriority (* unchanged since 4627 *)
{
(OOVPA*)&GetThreadPriority_1_0_4627,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuGetThreadPriority"
#endif
},
// GetTimeZoneInformation (* unchanged since 3911 *)
{
(OOVPA*)&GetTimeZoneInformation_1_0_3911,
XTL::EmuGetTimeZoneInformation,
#ifdef _DEBUG_TRACE
"GetTimeZoneInformation"
#endif
},
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// XMountMUA
{

76
src/CxbxKrnl/HLEDataBase/Xapi.1.0.5849.inl
View File

@ -211,6 +211,36 @@ SOOVPA<6> SwitchToThread_1_0_5849 =
// ******************************************************************
OOVPATable XAPI_1_0_5849[] =
{
// SetThreadPriority (* unchanged since 3911 *)
{
(OOVPA*)&SetThreadPriority_1_0_3911,
XTL::EmuSetThreadPriority,
#ifdef _DEBUG_TRACE
"EmuSetThreadPriority"
#endif
},
// QueryPerformanceCounter (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceCounter_1_0_4361,
XTL::EmuQueryPerformanceCounter,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceCounter"
#endif
},
// QueryPerformanceFrequency (* unchanged since 4361 *)
{
(OOVPA*)&QueryPerformanceFrequency_1_0_4361,
XTL::EmuQueryPerformanceFrequency,
#ifdef _DEBUG_TRACE
"EmuQueryPerformanceFrequency"
#endif
},
// XMountUtilityDrive (* unchanged since 4432 *)
{
(OOVPA*)&XMountUtilityDrive_1_0_4432,
@ -293,6 +323,52 @@ OOVPATable XAPI_1_0_5849[] =
#endif
},
//*/
// QueueUserAPC (* unchanged since 3911 *)
{
(OOVPA*)&QueueUserAPC_1_0_3911,
XTL::EmuQueueUserAPC,
#ifdef _DEBUG_TRACE
"EmuQueueUserAPC"
#endif
},
// GetThreadPriority
{
(OOVPA*)&GetThreadPriority_1_0_5849,
XTL::EmuGetThreadPriority,
#ifdef _DEBUG_TRACE
"GetThreadPriority"
#endif
},
// SetThreadPriorityBoost
{
(OOVPA*)&SetThreadPriorityBoost_1_0_5849,
XTL::EmuSetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"SetThreadPriorityBoost"
#endif
},
// GetThreadPriorityBoost
/*{
(OOVPA*)&GetThreadPriorityBoost_1_0_5849,
XTL::EmuGetThreadPriorityBoost,
#ifdef _DEBUG_TRACE
"GetThreadPriorityBoost"
#endif
},*/
// RaiseException
{
(OOVPA*)&RaiseException_1_0_5849,
XTL::EmuRaiseException,
#ifdef _DEBUG_TRACE
"RaiseException"
#endif
},
// XLaunchNewImageA (* unchanged since 5558 *)
{
(OOVPA*)&XLaunchNewImageA_1_0_5558,

4
src/CxbxKrnl/KernelThunk.cpp
View File

@ -212,7 +212,7 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)PANIC(0x0091), // 0x0091 (145) KeSetEvent
(uint32)PANIC(0x0092), // 0x0092 (146) KeSetEventBoostPriority
(uint32)PANIC(0x0093), // 0x0093 (147) KeSetPriorityProcess
(uint32)PANIC(0x0094), // 0x0094 (148) KeSetPriorityThread
(uint32)FUNC(&xboxkrnl::KeSetPriorityThread), // 0x0094 (148)
(uint32)FUNC(&xboxkrnl::KeSetTimer), // 0x0095 (149)
(uint32)FUNC(&xboxkrnl::KeSetTimerEx), // 0x0096 (150)
(uint32)PANIC(0x0097), // 0x0097 (151) KeStallExecutionProcessor
@ -297,7 +297,7 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)PANIC(0x00E6), // 0x00E6 (230) NtSignalAndWaitForSingleObjectEx
(uint32)FUNC(&xboxkrnl::NtSuspendThread), // 0x00E7 (231)
(uint32)FUNC(&xboxkrnl::NtUserIoApcDispatcher), // 0x00E8 (232)
(uint32)PANIC(0x00E9), // 0x00E9 (233) NtWaitForSingleObject
(uint32)FUNC(&xboxkrnl::NtWaitForSingleObject), // 0x00E9 (233)
(uint32)FUNC(&xboxkrnl::NtWaitForSingleObjectEx), // 0x00EA (234)
(uint32)FUNC(&xboxkrnl::NtWaitForMultipleObjectsEx), // 0x00EB (235)
(uint32)FUNC(&xboxkrnl::NtWriteFile), // 0x00EC (236)