/**
* This is called when we exit.
* We call all the SPU's cleanup functions.
*/
static void stubSPUTearDownLocked(void)
{
crDebug("stubSPUTearDownLocked");
#ifdef WINDOWS
# ifndef CR_NEWWINTRACK
stubUninstallWindowMessageHook();
# endif
#endif
#ifdef CR_NEWWINTRACK
ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
#endif
//delete all created contexts
stubMakeCurrent( NULL, NULL);
/* the lock order is windowTable->contextTable (see wglMakeCurrent_prox, glXMakeCurrent)
* this is why we need to take a windowTable lock since we will later do stub.windowTable access & locking */
crHashtableLock(stub.windowTable);
crHashtableWalk(stub.contextTable, hsWalkStubDestroyContexts, NULL);
crHashtableUnlock(stub.windowTable);
/* shutdown, now trap any calls to a NULL dispatcher */
crSPUCopyDispatchTable(&glim, &stubNULLDispatch);
crSPUUnloadChain(stub.spu);
stub.spu = NULL;
#ifndef Linux
crUnloadOpenGL();
#endif
#ifndef WINDOWS
crNetTearDown();
#endif
#ifdef GLX
if (stub.xshmSI.shmid>=0)
{
shmctl(stub.xshmSI.shmid, IPC_RMID, 0);
shmdt(stub.xshmSI.shmaddr);
}
crFreeHashtable(stub.pGLXPixmapsHash, crFree);
#endif
crFreeHashtable(stub.windowTable, crFree);
crFreeHashtable(stub.contextTable, NULL);
crMemset(&stub, 0, sizeof(stub));
}
static void crServerTearDown( void )
{
GLint i;
/* avoid a race condition */
if (tearingdown)
return;
tearingdown = 1;
crStateSetCurrent( NULL );
cr_server.curClient = NULL;
cr_server.run_queue = NULL;
crFree( cr_server.overlap_intens );
cr_server.overlap_intens = NULL;
/* Deallocate all semaphores */
crFreeHashtable(cr_server.semaphores, crFree);
cr_server.semaphores = NULL;
/* Deallocate all barriers */
crFreeHashtable(cr_server.barriers, DeleteBarrierCallback);
cr_server.barriers = NULL;
/* Free all context info */
crFreeHashtable(cr_server.contextTable, deleteContextCallback);
/* Free vertex programs */
crFreeHashtable(cr_server.programTable, crFree);
for (i = 0; i < cr_server.numClients; i++) {
if (cr_server.clients[i]) {
CRConnection *conn = cr_server.clients[i]->conn;
crNetFreeConnection(conn);
crFree(cr_server.clients[i]);
}
}
cr_server.numClients = 0;
#if 1
/* disable these two lines if trying to get stack traces with valgrind */
crSPUUnloadChain(cr_server.head_spu);
cr_server.head_spu = NULL;
#endif
crUnloadOpenGL();
}
static int renderSPUCleanup(void)
{
renderspuVBoxCompositorClearAll();
if (render_spu.blitterTable)
{
crFreeHashtable(render_spu.blitterTable, DeleteBlitterCallback);
render_spu.blitterTable = NULL;
}
else
{
crHashtableWalk(render_spu.windowTable, renderspuBlitterCleanupCB, NULL);
crHashtableWalk(render_spu.dummyWindowTable, renderspuBlitterCleanupCB, NULL);
}
renderspuSetDefaultSharedContext(NULL);
crFreeHashtable(render_spu.contextTable, DeleteContextCallback);
render_spu.contextTable = NULL;
crFreeHashtable(render_spu.windowTable, DeleteWindowCallback);
render_spu.windowTable = NULL;
crFreeHashtable(render_spu.dummyWindowTable, DeleteWindowCallback);
render_spu.dummyWindowTable = NULL;
crFreeHashtable(render_spu.barrierHash, crFree);
render_spu.barrierHash = NULL;
#ifdef RT_OS_DARWIN
# ifndef VBOX_WITH_COCOA_QT
render_spu.fInit = false;
DisposeEventHandlerUPP(render_spu.hParentEventHandler);
ReleaseWindowGroup(render_spu.pMasterGroup);
ReleaseWindowGroup(render_spu.pParentGroup);
if (render_spu.hRootVisibleRegion)
{
DisposeRgn(render_spu.hRootVisibleRegion);
render_spu.hRootVisibleRegion = 0;
}
render_spu.currentBufferName = 1;
render_spu.uiDockUpdateTS = 0;
RTSemFastMutexDestroy(render_spu.syncMutex);
# else /* VBOX_WITH_COCOA_QT */
# endif /* VBOX_WITH_COCOA_QT */
#endif /* RT_OS_DARWIN */
#ifdef RT_OS_WINDOWS
if (render_spu.dwWinThreadId)
{
HANDLE hNative;
hNative = OpenThread(SYNCHRONIZE|THREAD_QUERY_INFORMATION|THREAD_TERMINATE,
false, render_spu.dwWinThreadId);
if (!hNative)
{
crWarning("Failed to get handle for window thread(%#x)", GetLastError());
}
if (PostThreadMessage(render_spu.dwWinThreadId, WM_QUIT, 0, 0))
{
WaitForSingleObject(render_spu.hWinThreadReadyEvent, INFINITE);
/*wait for os thread to actually finish*/
if (hNative && WaitForSingleObject(hNative, 3000)==WAIT_TIMEOUT)
{
crDebug("Wait failed, terminating");
if (!TerminateThread(hNative, 1))
{
crWarning("TerminateThread failed");
}
}
}
if (hNative)
{
CloseHandle(hNative);
}
}
CloseHandle(render_spu.hWinThreadReadyEvent);
render_spu.hWinThreadReadyEvent = NULL;
#endif
crUnloadOpenGL();
#ifdef CHROMIUM_THREADSAFE
crFreeTSD(&_RenderTSD);
#endif
return 1;
}
