Exemple #1
0
// ******************************************************************
// * EmuIXACTSoundBank_Play
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTSoundBank_Play
(
	X_XACTSoundBank*	pThis,
	DWORD				dwSoundCueIndex,
	X_XACTSoundSource*	pSoundSource,
	DWORD				dwFlags,
	X_XACTSoundCue**	ppSoundCue
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTSoundBank_Play\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   dwSoundCueIndex           : 0x%.08X\n"
		   "   pSoundSource              : 0x%.08X\n"
		   "   dwFlags                   : 0x%.08X\n"
		   "   ppSoundCue                : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, dwSoundCueIndex, pSoundSource, dwFlags, ppSoundCue);

	EmuSwapFS();

	return S_OK;
}
Exemple #2
0
// ******************************************************************
// * EmuIXACTEngine_CreateSoundBank
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_CreateSoundBank
(
	X_XACTEngine*		pThis,
	LPVOID				pvData,
	DWORD				dwSize,
	X_XACTSoundBank**	ppSoundBank
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_CreateSoundBank\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
           "   pvData                    : 0x%.08X\n"
		   "   dwSize                    : 0x%.08X\n"
		   "   ppSoundBank               : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, pvData, dwSize, ppSoundBank);

	// TODO: Implement

	*ppSoundBank = (X_XACTSoundBank*) CxbxMalloc( sizeof( X_XACTSoundBank ) );

	EmuSwapFS();	// Xbox FS

	return S_OK;
}
Exemple #3
0
// ******************************************************************
// * EmuIXACTSoundSource_SetVelocity
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTSoundSource_SetVelocity
(
	X_XACTSoundSource*	pThis,
    FLOAT				x,
    FLOAT				y,
    FLOAT				z,
    DWORD				dwApply
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTSoundSource_SetVelocity\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   x                         : %f\n"
		   "   y                         : %f\n"
		   "   z                         : %f\n"
		   "   dwApply                   : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, x, y, z, dwApply);

	EmuSwapFS();

	return S_OK;
}
Exemple #4
0
// ******************************************************************
// * EmuIXACTEngine_SetListenerVelocity
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_SetListenerVelocity
(
	X_XACTEngine*	pThis,
	float			x,
	float			y, 
	float			z,
	DWORD			dwApply
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_SetListenerVelocity\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   x                         : %f"
		   "   y                         : %f"
		   "   z                         : %f"
		   "   dwApply                   : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, x, y, z, dwApply);

	EmuSwapFS();

	return S_OK;
}
Exemple #5
0
// ******************************************************************
// * EmuIXACTEngine_SetListenerOrientation
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_SetListenerOrientation
(
	X_XACTEngine*	pThis,
	float			xFront,
	float			yFront,
	float			zFront,
	float			xTop,
	float			yTop,
	float			zTop,
	DWORD			dwApply
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_SetListenerOrientation\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   xFront                    : %f"
		   "   yFront                    : %f"
		   "   zFront                    : %f"
		   "   xTop                      : %f"
		   "   yTop                      : %f"
		   "   zTop                      : %f"
		   "   dwApply                   : 0x%.08X"
           ");\n",
           GetCurrentThreadId(), pThis, xFront, yFront, zFront, xTop, yTop, zTop, dwApply);

	EmuSwapFS();

	return S_OK;
}
Exemple #6
0
// ******************************************************************
// * EmuIXACTEngine_DownloadEffectsImage
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_DownloadEffectsImage
(
	X_XACTEngine*		pThis,
	PVOID				pvData,
	DWORD				dwSize,
	LPVOID				pEffectLoc,
	LPVOID*				ppImageDesc
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_DownloadEffectsImage\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   pvData                    : 0x%.08X\n"
		   "   dwSize                    : 0x%.08X\n"
		   "   pEffectLoc                : 0x%.08X\n"
		   "   ppImageDesc               : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, dwSize, pEffectLoc, ppImageDesc);

	// TODO: Implement

	EmuSwapFS();	// Xbox FS

	return S_OK;
}
Exemple #7
0
// ******************************************************************
// * EmuIXACTEngine_RegisterStreamedWaveBank
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_RegisterStreamedWaveBank
(
	X_XACTEngine*							pThis,
	X_XACT_WAVEBANK_STREAMING_PARAMETERS*	pParams,
	X_XACTWaveBank**						ppWaveBank
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_RegisterWaveBank\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
           "   pParams                   : 0x%.08X\n"
		   "   ppWaveBank                : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, pParams, ppWaveBank);

	// TODO: Implement

	*ppWaveBank = (X_XACTWaveBank*) CxbxMalloc( sizeof( X_XACTWaveBank ) );

	EmuSwapFS();	// Xbox FS

	return S_OK;
}
Exemple #8
0
extern "C" CXBXKRNL_API void CxbxKrnlNoFunc()
{
    EmuSwapFS();   // Win2k/XP FS

    DbgPrintf("EmuMain (0x%X): CxbxKrnlNoFunc()\n", GetCurrentThreadId());

    EmuSwapFS();   // XBox FS
}
Exemple #9
0
extern "C" CXBXKRNL_API void CxbxKrnlPanic()
{
    if(EmuIsXboxFS())
        EmuSwapFS();   // Win2k/XP FS

    DbgPrintf("EmuMain (0x%X): CxbxKrnlPanic()\n", GetCurrentThreadId());

    CxbxKrnlCleanup("Kernel Panic!");

    EmuSwapFS();   // XBox FS
}
// ******************************************************************
// * EmuIXACTEngine_CommitDeferredSettings
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_CommitDeferredSettings(X_XACTEngine* pThis)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_CommitDeferredSettings\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis);

	EmuSwapFS();

	return S_OK;
}
// ******************************************************************
// * EmuXACTEngineDoWork
// ******************************************************************
void WINAPI XTL::EmuXACTEngineDoWork()
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuXACTEngineCreate()\n", GetCurrentThreadId() );

	// TODO: Anything else required here?
	// AFAIK, this function just calls DirectSoundDoWork()

	//EmuSwapFS();
	//EmuDirectSoundDoWork();
	//EmuSwapFS();

	EmuSwapFS();	// Xbox FS
}
Exemple #12
0
extern "C" CXBXKRNL_API void CxbxKrnlTerminateThread()
{
    if(EmuIsXboxFS())
        EmuSwapFS();    // Win2k/XP FS

    EmuCleanupFS();

    TerminateThread(GetCurrentThread(), 0);
}
// ******************************************************************
// * EmuIXACTEngine_RegisterNotification
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_RegisterNotification
(
	X_XACTEngine*					pThis,
    PCXACT_NOTIFICATION_DESCRIPTION pNotificationDesc
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_RegisterNotification\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   pNotificationDesc         : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, pNotificationDesc);

	EmuSwapFS();

	return S_OK;
}
// ******************************************************************
// * EmuIXACTEngine_EnableHeadphones
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_EnableHeadphones
(
	X_XACTEngine*		pThis,
	BOOL				fEnabled
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_EnableHeadphones\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   fEnabled                  : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, fEnabled);

	EmuSwapFS();

	return S_OK;
}
// ******************************************************************
// * EmuIXACTSoundBank_GetSoundCueIndexFromFriendlyName
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTSoundBank_GetSoundCueIndexFromFriendlyName
(
	X_XACTEngine*		pThis,
	PCSTR				pFriendlyName,
	DWORD*				pdwSoundCueIndex
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTSoundBank_GetSoundCueIndexFromFriendlyName\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   pFriendlyName             : (%s)\n"
		   "   pdwSoundCueIndex          : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, pFriendlyName, pdwSoundCueIndex);

	EmuSwapFS();

	return S_OK;
}
// ******************************************************************
// * EmuIXACTEngine_SetMasterVolume
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_SetMasterVolume
(
	X_XACTEngine*	pThis,
    WORD			wCategory,
    LONG			lVolume
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_SetMasterVolume\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   wCategory                 : 0x%.08X\n"
		   "   lVolume                   : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, wCategory, lVolume);

	EmuSwapFS();

	return S_OK;
}
Exemple #17
0
// ******************************************************************
// * func: EmuXGIsSwizzledFormat
// ******************************************************************
PVOID WINAPI XTL::EmuXGIsSwizzledFormat
(
    XTL::D3DFORMAT Format
)
{
    // ******************************************************************
    // * debug trace
    // ******************************************************************
    #ifdef _DEBUG_TRACE
    {
        EmuSwapFS();   // Win2k/XP FS
        DbgPrintf("EmuXapi (0x%X): EmuXGIsSwizzledFormat\n"
               "(\n"
               "   Format              : 0x%.08X\n"
               ");\n",
               GetCurrentThreadId(), Format);
        EmuSwapFS();   // Xbox FS
    }
    #endif

    return FALSE;
}
// ******************************************************************
// * func: EmuXACTEngineCreate
// ******************************************************************
HRESULT WINAPI XTL::EmuXACTEngineCreate
(
	X_XACT_RUNTIME_PARAMETERS* pParams, 
	X_XACTEngine** ppEngine
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuXACTEngineCreate\n"
           "(\n"
           "   pParams                   : 0x%.08X\n"
           "   ppEngine                  : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pParams, ppEngine);

	// TODO: Any other form of initialization?

	*ppEngine = (X_XACTEngine*) CxbxMalloc( sizeof( X_XACTEngine ) );

	EmuSwapFS();	// Xbox FS
	
	return S_OK;
}
// ******************************************************************
// * EmuIXACTEngine_CreateSoundSource
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_CreateSoundSource
(
	X_XACTEngine*		pThis,
	DWORD				dwFlags,
	X_XACTSoundSource** ppSoundSource
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_CreateSoundSource\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   dwFlags                   : 0x%.08X\n"
		   "   ppSoundSource             : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, dwFlags, ppSoundSource);

	*ppSoundSource = (X_XACTSoundSource*) CxbxMalloc( sizeof( X_XACTSoundSource ) );

	EmuSwapFS();

	return S_OK;
}
// ******************************************************************
// * EmuIXACTEngine_GetNotification
// ******************************************************************
HRESULT WINAPI XTL::EmuIXACTEngine_GetNotification
(
	X_XACTEngine*					pThis,
    PCXACT_NOTIFICATION_DESCRIPTION pNotificationDesc,
    LPVOID						    pNotification
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXactEng (0x%X): EmuIXACTEngine_GetNotification\n"
           "(\n"
           "   pThis                     : 0x%.08X\n"
		   "   pNotificationDesc         : 0x%.08X\n"
		   "   pNotification             : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pThis, pNotificationDesc, pNotification);

	// TODO: The contents of XACT_NOTIFICATION can vary from one XDK to the next.
	// The definition for 4627 is different than 5558.

	EmuSwapFS();

	return S_OK;
}
Exemple #21
0
// ******************************************************************
// * func: EmuXGSetTextureHeader
// ******************************************************************
VOID WINAPI XTL::EmuXGSetTextureHeader
(
	UINT			Width,
	UINT			Height,
	UINT			Levels,
	DWORD			Usage,
	D3DFORMAT		Format,
	D3DPOOL			Pool,
	X_D3DTexture*	pTexture,
	UINT			Data,
	UINT			Pitch
)
{
	EmuSwapFS();	// Win2k/XP FS

	DbgPrintf("EmuXapi (0x%X): EmuXGSetTextureHeader\n"
           "(\n"
           "   Width                  : 0x%.08X\n"
		   "   Height                 : 0x%.08X\n"
		   "   Levels                 : 0x%.08X\n"
		   "   Usage                  : 0x%.08X\n"
		   "   Format                 : 0x%.08X\n"
		   "   Pool                   : 0x%.08X\n"
		   "   pTexture               : 0x%.08X\n"
		   "   Data                   : 0x%.08X\n"
		   "   Pitch                  : 0x%.08X\n"
		   ");\n",
		   GetCurrentThreadId(), Width, Height, Levels, Usage, 
				Format, Pool, pTexture, Data, Pitch);

	// NOTES: This function simply creates a texture that needs to be registered
	// via D3DDevice_Register afterwards.  So, do I just create the texture via
	// EmuIDirect3DDevice8_CreateTexture, or just fill in the interface and let
	// EmuIDirect3DDevice8_Register do the rest?  Trial and error.

	X_D3DTexture* pTempTexture = NULL;
	DWORD l2w = (DWORD) log( (float)Width ) / log(2.0f);
	DWORD l2h = (DWORD) log( (float)Height ) / log(2.0f);

	/*if( Data != 0 )
		CxbxKrnlCleanup( "Data != 0 (XGSetTextureHeader)" );

	if( Pitch != 0 )
		CxbxKrnlCleanup( "Pitch != 0 (XGSetTextureHeader)" );*/

	// Generate a temporary texture and fill in the necessary fields within
	// the X_D3DTexture interface (lazy, I know).
	EmuSwapFS();
	pTempTexture = (X_D3DTexture*) XTL::EmuIDirect3DDevice8_CreateTexture2(Width, Height, 0, Levels, Usage, Format, 
		XTL::D3DRTYPE_TEXTURE);
	EmuSwapFS();

	pTexture->Data		= pTempTexture->Data;
	pTexture->Common	= X_D3DCOMMON_TYPE_TEXTURE; //pTempTexture->Common;
//	pTexture->Format	= pTempTexture->Format;
	pTexture->Lock		= pTempTexture->Lock; // 0;
	pTexture->Size		= pTempTexture->Size;

	EmuSwapFS();
	XTL::EmuIDirect3DResource8_Release(pTempTexture);
	EmuSwapFS();

	// Manually fill in Format parameters
	/*pTexture->Format |= ( ( ( Width >> 1 ) & 0xF ) << X_D3DFORMAT_USIZE_SHIFT ) |	// Width
					   ( ( ( Height>> 1 ) & 0xF ) << X_D3DFORMAT_VSIZE_SHIFT ) |	// Height
					   ( ( ( Levels     ) & 0xF ) << X_D3DFORMAT_MIPMAP_SHIFT ) |	// Mip Levels
				//	   ( ( ( ((DWORD)Format)) & 0xFF ) << X_D3DFORMAT_FORMAT_SHIFT ) |	// Format (Already set)
					   ( ( ( 2			) & 0xF ) << X_D3DFORMAT_DIMENSION_SHIFT );	// Dimensions
*/
	pTexture->Format |= ( ( l2w & 0xF ) << X_D3DFORMAT_USIZE_SHIFT );
	pTexture->Format |= ( ( l2h & 0xF ) << X_D3DFORMAT_VSIZE_SHIFT );
	pTexture->Format |= ( ( Levels & 0xF ) << X_D3DFORMAT_MIPMAP_SHIFT );
	pTexture->Format |= ( ( ( ((DWORD)Format)) & 0xFF ) << X_D3DFORMAT_FORMAT_SHIFT );
	pTexture->Format |= ( ( 2 & 0xF ) << X_D3DFORMAT_DIMENSION_SHIFT );

//	D3DCOLOR_XRGB(
	DbgPrintf( "pTexture->Format:= 0x%.08X\n", pTexture->Format );

	EmuSwapFS();	// Xbox FS
}
Exemple #22
0
extern "C" CXBXKRNL_API void CxbxKrnlInit
(
    HWND                    hwndParent,
    void                   *pTLSData,
    Xbe::TLS               *pTLS,
    Xbe::LibraryVersion    *pLibraryVersion,
    DebugMode               DbgMode,
    char                   *szDebugFilename,
    Xbe::Header            *pXbeHeader,
    uint32                  dwXbeHeaderSize,
    void                  (*Entry)())
{
    // update caches
    CxbxKrnl_TLS = pTLS;
    CxbxKrnl_TLSData = pTLSData;
    CxbxKrnl_XbeHeader = pXbeHeader;
    CxbxKrnl_hEmuParent = IsWindow(hwndParent) ? hwndParent : NULL;

    // for unicode conversions
    setlocale(LC_ALL, "English");

    // debug console allocation (if configured)
    if(DbgMode == DM_CONSOLE)
    {
        if(AllocConsole())
        {
            freopen("CONOUT$", "wt", stdout);
            freopen("CONIN$", "rt", stdin);

            SetConsoleTitle("Cxbx : Kernel Debug Console");

            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED);

            printf("EmuMain (0x%X): Cxbx Version %s\n", GetCurrentThreadId(), _CXBX_VERSION);
            printf("EmuMain (0x%X): Debug Console Allocated (DM_CONSOLE).\n", GetCurrentThreadId());
        }
    }
    else if(DbgMode == DM_FILE)
    {
        FreeConsole();

        freopen(szDebugFilename, "wt", stdout);

        printf("EmuMain (0x%X): Cxbx Version %s\n", GetCurrentThreadId(), _CXBX_VERSION);
        printf("EmuMain (0x%X): Debug Console Allocated (DM_FILE).\n", GetCurrentThreadId());
    }
    else
    {
        FreeConsole();

        char buffer[16];

        if(GetConsoleTitle(buffer, 16) != NULL)
            freopen("nul", "w", stdout);
    }

    //
    // debug trace
    //

    {
        #ifdef _DEBUG_TRACE
        printf("EmuMain (0x%X): Debug Trace Enabled.\n", GetCurrentThreadId());

        printf("EmuMain (0x%X): CxbxKrnlInit\n"
               "(\n"
               "   hwndParent          : 0x%.08X\n"
               "   pTLSData            : 0x%.08X\n"
               "   pTLS                : 0x%.08X\n"
               "   pLibraryVersion     : 0x%.08X\n"
               "   DebugConsole        : 0x%.08X\n"
               "   DebugFilename       : \"%s\"\n"
               "   pXBEHeader          : 0x%.08X\n"
               "   pXBEHeaderSize      : 0x%.08X\n"
               "   Entry               : 0x%.08X\n"
               ");\n",
               GetCurrentThreadId(), hwndParent, pTLSData, pTLS, pLibraryVersion, DbgMode, szDebugFilename, pXbeHeader, dwXbeHeaderSize, Entry);

        #else
        printf("EmuMain (0x%X): Debug Trace Disabled.\n", GetCurrentThreadId());
        #endif
    }

    //
    // load the necessary pieces of XbeHeader
    //

    {
        Xbe::Header *MemXbeHeader = (Xbe::Header*)0x00010000;

        uint32 old_protection = 0;

        VirtualProtect(MemXbeHeader, 0x1000, PAGE_READWRITE, &old_protection);

        // we sure hope we aren't corrupting anything necessary for an .exe to survive :]
        MemXbeHeader->dwSizeofHeaders   = pXbeHeader->dwSizeofHeaders;
        MemXbeHeader->dwCertificateAddr = pXbeHeader->dwCertificateAddr;
        MemXbeHeader->dwPeHeapReserve   = pXbeHeader->dwPeHeapReserve;
        MemXbeHeader->dwPeHeapCommit    = pXbeHeader->dwPeHeapCommit;

        memcpy(&MemXbeHeader->dwInitFlags, &pXbeHeader->dwInitFlags, sizeof(pXbeHeader->dwInitFlags));

        memcpy((void*)pXbeHeader->dwCertificateAddr, &((uint08*)pXbeHeader)[pXbeHeader->dwCertificateAddr - 0x00010000], sizeof(Xbe::Certificate));
    }

    //
    // initialize current directory
    //

    {
        char szBuffer[260];

        g_EmuShared->GetXbePath(szBuffer);

        if(szBuffer && *szBuffer)
            SetCurrentDirectory(szBuffer);
        else
            GetCurrentDirectory(260, szBuffer);

        g_strCurDrive = _strdup(szBuffer);

        g_hCurDir = CreateFile(szBuffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

        if(g_hCurDir == INVALID_HANDLE_VALUE)
            CxbxKrnlCleanup("Could not map D:\\\n");

        DbgPrintf("EmuMain (0x%X): CurDir := %s\n", GetCurrentThreadId(), szBuffer);
    }

    //
    // initialize EmuDisk
    //

    {
        char szBuffer[260];

        SHGetSpecialFolderPath(NULL, szBuffer, CSIDL_APPDATA, TRUE);

        strcat(szBuffer, "\\Cxbx\\");

        CreateDirectory(szBuffer, NULL);

        sint32 spot = -1;

        for(int v=0;v<260;v++)
        {
            if(szBuffer[v] == '\\') { spot = v; }
            else if(szBuffer[v] == '\0') { break; }
        }

        if(spot != -1) { szBuffer[spot] = '\0'; }

        Xbe::Certificate *pCertificate = (Xbe::Certificate*)pXbeHeader->dwCertificateAddr;

        //
        // create EmuDisk directory
        //

        strcpy(&szBuffer[spot], "\\EmuDisk");

        CreateDirectory(szBuffer, NULL);

        //
        // create T:\ directory
        //

        {
            strcpy(&szBuffer[spot], "\\EmuDisk\\T");

            CreateDirectory(szBuffer, NULL);

            sprintf(&szBuffer[spot+10], "\\%08x", pCertificate->dwTitleId);

            CreateDirectory(szBuffer, NULL);

            g_strTDrive = _strdup(szBuffer);

            g_hTDrive = CreateFile(szBuffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

            if(g_hTDrive == INVALID_HANDLE_VALUE)
                CxbxKrnlCleanup("Could not map T:\\\n");

            DbgPrintf("EmuMain (0x%X): T Data := %s\n", GetCurrentThreadId(), szBuffer);
        }

        //
        // create U:\ directory
        //

        {
            strcpy(&szBuffer[spot], "\\EmuDisk\\U");

            CreateDirectory(szBuffer, NULL);

            sprintf(&szBuffer[spot+10], "\\%08x", pCertificate->dwTitleId);

            CreateDirectory(szBuffer, NULL);

            g_strUDrive = _strdup(szBuffer);

            g_hUDrive = CreateFile(szBuffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

            if(g_hUDrive == INVALID_HANDLE_VALUE)
                CxbxKrnlCleanup("Could not map U:\\\n");

            DbgPrintf("EmuMain (0x%X): U Data := %s\n", GetCurrentThreadId(), szBuffer);
        }

        //
        // create Z:\ directory
        //

        {
            strcpy(&szBuffer[spot], "\\EmuDisk\\Z");

            CreateDirectory(szBuffer, NULL);

            //* is it necessary to make this directory title unique?
            sprintf(&szBuffer[spot+10], "\\%08x", pCertificate->dwTitleId);

            CreateDirectory(szBuffer, NULL);
            //*/

            g_strZDrive = _strdup(szBuffer);

            g_hZDrive = CreateFile(szBuffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

            if(g_hUDrive == INVALID_HANDLE_VALUE)
                CxbxKrnlCleanup("Could not map Z:\\\n");

            DbgPrintf("EmuMain (0x%X): Z Data := %s\n", GetCurrentThreadId(), szBuffer);
        }
    }

    //
    // initialize FS segment selector
    //

    {
        EmuInitFS();

        EmuGenerateFS(pTLS, pTLSData);
    }

    //
    // duplicate handle in order to retain Suspend/Resume thread rights from a remote thread
    //

    {
        HANDLE hDupHandle = NULL;

        DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &hDupHandle, 0, FALSE, DUPLICATE_SAME_ACCESS);

        CxbxKrnlRegisterThread(hDupHandle);
    }

	//
	// Clear critical section list
	//
	//extern void InitializeSectionStructures(void); 
	InitializeSectionStructures();

    DbgPrintf("EmuMain (0x%X): Initializing Direct3D.\n", GetCurrentThreadId());

    XTL::EmuD3DInit(pXbeHeader, dwXbeHeaderSize);

    EmuHLEIntercept(pLibraryVersion, pXbeHeader);

    DbgPrintf("EmuMain (0x%X): Initial thread starting.\n", GetCurrentThreadId());

    //
    // Xbe entry point
    //

    __try
    {
        EmuSwapFS();   // XBox FS

        // _USE_XGMATH Disabled in mesh :[
        // halo : dword_0_2E2D18
        // halo : 1744F0 (bink)
        //_asm int 3;

        /*
        for(int v=0;v<sizeof(funcAddr)/sizeof(uint32);v++)
        {
            bool bExclude = false;
            for(int r=0;r<sizeof(funcExclude)/sizeof(uint32);r++)
            {
                if(funcAddr[v] == funcExclude[r])
                {
                    bExclude = true;
                    break;
                }
            }

            if(!bExclude)
            {
                *(uint08*)(funcAddr[v]) = 0xCC;
            }
        }
        //*/

        Entry();

        EmuSwapFS();   // Win2k/XP FS
    }
    __except(EmuException(GetExceptionInformation()))
    {
        printf("Emu: WARNING!! Problem with ExceptionFilter\n");
    }

    DbgPrintf("EmuMain (0x%X): Initial thread ended.\n", GetCurrentThreadId());

    fflush(stdout);

    CxbxKrnlTerminateThread();

    return;
}
Exemple #23
0
// ******************************************************************
// * func: EmuXGSwizzleRect
// ******************************************************************
VOID WINAPI XTL::EmuXGSwizzleRect
(
    LPCVOID       pSource,
    DWORD         Pitch,
    LPCRECT       pRect,
    LPVOID        pDest,
    DWORD         Width,
    DWORD         Height,
    CONST LPPOINT pPoint,
    DWORD         BytesPerPixel
)
{
    EmuSwapFS();   // Win2k/XP FS

    DbgPrintf("EmuXapi (0x%X): EmuXGSwizzleRect\n"
           "(\n"
           "   pSource             : 0x%.08X\n"
           "   Pitch               : 0x%.08X\n"
           "   pRect               : 0x%.08X\n"
           "   pDest               : 0x%.08X\n"
           "   Width               : 0x%.08X\n"
           "   Height              : 0x%.08X\n"
           "   pPoint              : 0x%.08X\n"
           "   BytesPerPixel       : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pSource, Pitch, pRect, pDest, Width, Height,
           pPoint, BytesPerPixel);

    if(pRect == NULL && pPoint == NULL && Pitch == 0)
    {
        memcpy(pDest, pSource, Width*Height*BytesPerPixel);
    }
    else
    {
        if(pPoint != NULL && (pPoint->x != 0 || pPoint->y != 0))
            CxbxKrnlCleanup("Temporarily unsupported swizzle (very easy fix)");

        DWORD dwMaxY = Height;
        DWORD dwChunkSize = Width;

        uint08 *pSrc = (uint08*)pSource;
        uint08 *pDst = (uint08*)pDest;

        if(pRect != 0)
        {
            pSrc += pRect->top*Pitch;
            pSrc += pRect->left;

            dwMaxY = pRect->bottom - pRect->top;
            dwChunkSize = pRect->right - pRect->left;
        }

        for(DWORD y=0;y<dwMaxY;y++)
        {
            memcpy(pSrc, pDst, dwChunkSize);
            pSrc += Pitch;
            pDst += Pitch;
        }
    }

    EmuSwapFS();   // Xbox FS

    return;
}
Exemple #24
0
// ******************************************************************
// * func: EmuXGSwizzleBox
// ******************************************************************
VOID WINAPI XTL::EmuXGSwizzleBox
(
    LPCVOID          pSource,
    DWORD            RowPitch,
    DWORD            SlicePitch,
    CONST D3DBOX    *pBox,
    LPVOID           pDest,
    DWORD            Width,
    DWORD            Height,
    DWORD            Depth,
    CONST XGPOINT3D *pPoint,
    DWORD            BytesPerPixel
)
{
    EmuSwapFS();   // Win2k/XP FS

    DbgPrintf("EmuXapi (0x%X): EmuXGSwizzleBox\n"
           "(\n"
           "   pSource             : 0x%.08X\n"
           "   RowPitch            : 0x%.08X\n"
           "   SlicePitch          : 0x%.08X\n"
           "   pBox                : 0x%.08X\n"
           "   pDest               : 0x%.08X\n"
           "   Width               : 0x%.08X\n"
           "   Height              : 0x%.08X\n"
           "   Depth               : 0x%.08X\n"
           "   pPoint              : 0x%.08X\n"
           "   BytesPerPixel       : 0x%.08X\n"
           ");\n",
           GetCurrentThreadId(), pSource, RowPitch, SlicePitch, pBox, pDest, Width, Height,
           Depth, pPoint, BytesPerPixel);

	if(pDest != (LPVOID) 0x80000000)
	{
		if(pBox == NULL && pPoint == NULL && RowPitch == 0 && SlicePitch == 0)
		{
			memcpy(pDest, pSource, Width*Height*Depth*BytesPerPixel);
		}
		else
		{
			if(pPoint != NULL && (pPoint->u != 0 || pPoint->v != 0 || pPoint->w != 0))
				CxbxKrnlCleanup("Temporarily unsupported swizzle (very easy fix)");

			DWORD dwMaxY = Height;
			DWORD dwMaxZ = Depth;
			DWORD dwChunkSize = Width;

			uint08 *pSrc = (uint08*)pSource;
			uint08 *pDst = (uint08*)pDest;

			if(pBox != 0)
			{
				pSrc += pBox->Top*RowPitch;
				pSrc += pBox->Left;

				dwMaxY = pBox->Bottom - pBox->Top;
				dwChunkSize = pBox->Right - pBox->Left;
			}

			for(DWORD y=0;y<dwMaxY;y++)
			{
				memcpy(pSrc, pDst, dwChunkSize);
				pSrc += RowPitch;
				pDst += RowPitch;
			}
        }
	}

    EmuSwapFS();   // Xbox FS

    return;
}