Exemple #1
0
void Sys_Quit( void )
{
	timeEndPeriod( 1 );

	SV_Shutdown( "Server quit\n" );
	CL_Shutdown();

	if( dedicated && dedicated->integer )
		FreeConsole();

	// shut down QHOST hooks if necessary
	DeinitConProc();

	Qcommon_Shutdown();

	exit( 0 );
}
LC3Sound::~LC3Sound()
{
	/* stop the timer */
	timeEndPeriod( 20);
	timeKillEvent( gwid);

	lpSwSamp->Stop();
	lpSwSamp->Release();
	lpSwSamp = NULL;

	lpDirectSoundBuffer->Stop();
  	lpDirectSoundBuffer->Release();
  
	lpDirectSound->Release();
	lpDirectSound = NULL;
	free(soundData);
}
Exemple #3
0
void Sys_Error (const char *error, ...)
{
	va_list		argptr;
	char		text[1024];

	va_start (argptr, error);
	vsnprintf (text, sizeof(text), error, argptr);
	va_end (argptr);

	timeEndPeriod( 1 );

	CL_Shutdown ();
	Qcommon_Shutdown ();

	if (qDedConsole)
	{
		MSG		msg;
		BOOL	bRet;

		Conbuf_AppendText( text );
		Conbuf_AppendText( "\n" );

		Sys_SetErrorText( text );
		Sys_ShowConsole( 1, true );

		// wait for the user to quit
		while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0) {
			if (bRet == -1)
				break;

			TranslateMessage (&msg);
      		DispatchMessage (&msg);

			Sleep(25);
		}
	}
	else
	{
		MessageBox(NULL, text, "Error", 0 /* MB_OK */ );
	}

	Sys_DestroyConsole();

	exit (1);
}
Exemple #4
0
/*
=================
Sys_Error
=================
*/
void Sys_Error( const char *error, ... ) {
	va_list argptr;
	char    string[4096];
#if defined (_WIN32) && !defined (_DEBUG)
	MSG		msg;
#endif

	va_start (argptr,error);
	idStr::vsnPrintf (string, sizeof(string), error, argptr);
	va_end (argptr);

#if defined (_WIN32) && !defined (_DEBUG)
	Conbuf_AppendText( string );
	Conbuf_AppendText( "\n" );
#else
	// Print text in the console window/box
	Sys_Print( string );
	Sys_Print( "\n" );
#endif

#if defined (_WIN32) && !defined (_DEBUG)
	Sys_SetErrorText( string );
	Sys_ShowConsole( 1, qtrue );

	timeEndPeriod( 1 );

	IN_Shutdown();

	// wait for the user to quit
	while ( 1 ) {
		if ( !GetMessage( &msg, NULL, 0, 0 ) ) {
			Com_Quit_f();
		}
		TranslateMessage( &msg );
		DispatchMessage( &msg );
	}

	Sys_DestroyConsole();
#endif

	CL_Shutdown( );
	Sys_ErrorDialog( string );

	Sys_Exit( 1 );
}
CBaseReferenceClock::~CBaseReferenceClock()
{

    if (m_TimerResolution) timeEndPeriod(m_TimerResolution);

    m_pSchedule->DumpLinkedList();

    if (m_hThread)
    {
        m_bAbort = TRUE;
        TriggerThread();
        WaitForSingleObject( m_hThread, INFINITE );
        EXECUTE_ASSERT( CloseHandle(m_hThread) );
        m_hThread = 0;
        EXECUTE_ASSERT( CloseHandle(m_pSchedule->GetEvent()) );
	delete m_pSchedule;
    }
}
Exemple #6
0
int sanity_run(struct cpuid_state_t *state)
{
	sanity_handler_t *p = handlers;
	unsigned int ret = 0;
#ifdef TARGET_OS_WINDOWS
	TIMECAPS tc;
	timeGetDevCaps(&tc, sizeof(TIMECAPS));
	timeBeginPeriod(tc.wPeriodMin);
#endif
	while (*p) {
		if ((*p++)(state) != 0)
			ret = p - handlers;
	}
#ifdef TARGET_OS_WINDOWS
	timeEndPeriod(tc.wPeriodMin);
#endif
	return ret;
}
Exemple #7
0
void I_Quit()
{
    HasExited = true;		/* Prevent infinitely recursive exits -- killough */

    if (TimerEventID != 0)
    {
        timeKillEvent(TimerEventID);
    }
    if (NewTicArrived != NULL)
    {
        CloseHandle(NewTicArrived);
    }
    timeEndPeriod(TimerPeriod);
    if (demorecording)
    {
        G_CheckDemoStatus();
    }
}
BOOL APIENTRY DllMain(HANDLE hModule, 
					  DWORD  ul_reason_for_call, 
					  LPVOID lpReserved)
{
	switch( ul_reason_for_call ) {
	case DLL_PROCESS_ATTACH:
		{

// BUG - EXE/DLL Paths - start
		dllModule = hModule;

#ifdef _DEBUG
		MessageBox(0, "DLL attached", "Message", 0);
#endif
// BUG - EXE/DLL Paths - end

		// The DLL is being loaded into the virtual address space of the current process as a result of the process starting up 
		OutputDebugString("DLL_PROCESS_ATTACH\n");

		// set timer precision
		MMRESULT iTimeSet = timeBeginPeriod(1);		// set timeGetTime and sleep resolution to 1 ms, otherwise it's 10-16ms
		FAssertMsg(iTimeSet==TIMERR_NOERROR, "failed setting timer resolution to 1 ms");
		}
		break;
	case DLL_THREAD_ATTACH:
		// OutputDebugString("DLL_THREAD_ATTACH\n");
		break;
	case DLL_THREAD_DETACH:
		// OutputDebugString("DLL_THREAD_DETACH\n");
		break;
	case DLL_PROCESS_DETACH:

// BUG - EXE/DLL Paths - start
		dllModule = NULL;
// BUG - EXE/DLL Paths - end

		OutputDebugString("DLL_PROCESS_DETACH\n");
		timeEndPeriod(1);
		GC.setDLLIFace(NULL);
		break;
	}
	
	return TRUE;	// success
}
Exemple #9
0
//=============================================================================
// Call repeatedly by the main message loop in WinMain
//=============================================================================
void Game::run(HWND hwnd)
{
    if(graphics == NULL)            // if graphics not initialized
        return;

    // calculate elapsed time of last frame, save in frameTime
    QueryPerformanceCounter(&timeEnd);
    frameTime = (float)(timeEnd.QuadPart - timeStart.QuadPart ) / 
                (float)timerFreq.QuadPart;

    // Power saving code, requires winmm.lib
    // if not enough time has elapsed for desired frame rate
    if (frameTime < MIN_FRAME_TIME) 
    {
        sleepTime = (DWORD)((MIN_FRAME_TIME - frameTime)*1000);
        timeBeginPeriod(1);         // Request 1mS resolution for windows timer
        Sleep(sleepTime);           // release cpu for sleepTime
        timeEndPeriod(1);           // End 1mS timer resolution
        return;
    }

    if (frameTime > 0.0)
        fps = (fps*0.99f) + (0.01f/frameTime);  // average fps
    if (frameTime > MAX_FRAME_TIME) // if frame rate is very slow
        frameTime = MAX_FRAME_TIME; // limit maximum frameTime
    timeStart = timeEnd;

    // update(), ai(), and collisions() are pure virtual functions.
    // These functions must be provided in the class that inherits from Game.
    if (!paused)                    // if not paused
    {
        update();                   // update all game items
        ai();                       // artificial intelligence
        collisions();               // handle collisions
        input->vibrateControllers(frameTime); // handle controller vibration
    }
    renderGame();                   // draw all game items
    input->readControllers();       // read state of controllers


    // Clear input
    // Call this after all key checks are done
    input->clear(inputNS::KEYS_PRESSED);
}
Exemple #10
0
static void
SDL_SetSystemTimerResolution(const UINT uPeriod)
{
#ifndef __WINRT__
    static UINT timer_period = 0;

    if (uPeriod != timer_period) {
        if (timer_period) {
            timeEndPeriod(timer_period);
        }

        timer_period = uPeriod;

        if (timer_period) {
            timeBeginPeriod(timer_period);
        }
    }
#endif
}
Exemple #11
0
  GuiApp::~GuiApp() {

    //! close simulation
    exit_main(0);

    libManager->releaseLibrary("cfg_manager");
    libManager->releaseLibrary("lib_manager_gui");
    libManager->releaseLibrary("main_gui");

    libManager->clearLibraries();
    delete libManager;


#ifdef WIN32
    // end scheduler of 1ms
    timeEndPeriod(1);
#endif //WIN32

  }
Exemple #12
0
LOCAL TCALLBACK void
hal_close(struct THALBase *hal, struct TTask *task)
{
	struct HALSpecific *hws = hal->hmb_Specific;

	EnterCriticalSection(&hws->hsp_DevLock);

	if (hws->hsp_Timer)
	{
		if (--hws->hsp_RefCount == 0)
		{
			timeKillEvent(hws->hsp_Timer);
			timeEndPeriod(1);
			hws->hsp_Timer = TNULL;
		}
	}

	LeaveCriticalSection(&hws->hsp_DevLock);
}
void Game::run(HWND hWnd)
{
	if (graphics_ == NULL) // If graphics not initialized
	{
		return;
	}

	QueryPerformanceCounter(&timeEnd_);

	frameTime_ = (double)(timeEnd_.QuadPart - timeStart_.QuadPart) /
		(double)timerFreq_.QuadPart;

	// if the frame time is less than MIN_FRAME_TIME do idle processing
	//otherwise run game
	if (frameTime_ < MIN_FRAME_TIME)
	{
		//figure out how long to sleep for
		sleepTime_ = (DWORD)(MIN_FRAME_TIME - frameTime_) * 1000;
		timeBeginPeriod(1);// Request 1mS resolution for windows timer
		Sleep(sleepTime_); // Release CPU for sleepTime
		timeEndPeriod(1); // End 1mS timer resolution
		return;
	}
	if (frameTime_ > 0.0)
	{
		fps_ = (fps_ * .99) + (0.1 / frameTime_);
	}
	if (frameTime_ > MAX_FRAME_TIME)
	{
		frameTime_ = MAX_FRAME_TIME;
	}

	// reset the elapsed time to 0
	timeStart_ = timeEnd_;
	
	//Pure virtual functions defined by derived Classes
	update(); // Update all game items
	
	renderGame(); //renderGame() draws all items and calls pure virtual function render
	// Clear input
	// Call this after all key checks are done
	input_->clear(InputConstants::KEYS_PRESSED);
}
static void
gdk_frame_clock_idle_end_updating (GdkFrameClock *clock)
{
  GdkFrameClockIdle *clock_idle = GDK_FRAME_CLOCK_IDLE (clock);
  GdkFrameClockIdlePrivate *priv = clock_idle->priv;

  g_return_if_fail (priv->updating_count > 0);

  priv->updating_count--;
  maybe_stop_idle (clock_idle);

#ifdef G_OS_WIN32
  if (priv->updating_count == 0 && priv->begin_period)
    {
      timeEndPeriod(1);
      priv->begin_period = FALSE;
    }
#endif
}
Exemple #15
0
double currentTime()
{
    // Use a combination of ftime and QueryPerformanceCounter.
    // ftime returns the information we want, but doesn't have sufficient resolution.
    // QueryPerformanceCounter has high resolution, but is only usable to measure time intervals.
    // To combine them, we call ftime and QueryPerformanceCounter initially. Later calls will use QueryPerformanceCounter
    // by itself, adding the delta to the saved ftime.  We periodically re-sync to correct for drift.
    static bool started;
    static double syncLowResUTCTime;
    static double syncHighResUpTime;
    static double lastUTCTime;

    double lowResTime = lowResUTCTime();

    if (!qpcAvailable())
        return lowResTime / 1000.0;

    double highResTime = highResUpTime();

    if (!syncedTime) {
        timeBeginPeriod(1); // increase time resolution around low-res time getter
        syncLowResUTCTime = lowResTime = lowResUTCTime();
        timeEndPeriod(1); // restore time resolution
        syncHighResUpTime = highResTime;
        syncedTime = true;
    }

    double highResElapsed = highResTime - syncHighResUpTime;
    double utc = syncLowResUTCTime + highResElapsed;

    // force a clock re-sync if we've drifted
    double lowResElapsed = lowResTime - syncLowResUTCTime;
    const double maximumAllowedDriftMsec = 15.625 * 2.0; // 2x the typical low-res accuracy
    if (fabs(highResElapsed - lowResElapsed) > maximumAllowedDriftMsec)
        syncedTime = false;

    // make sure time doesn't run backwards (only correct if difference is < 2 seconds, since DST or clock changes could occur)
    const double backwardTimeLimit = 2000.0;
    if (utc < lastUTCTime && (lastUTCTime - utc) < backwardTimeLimit)
        return lastUTCTime / 1000.0;
    lastUTCTime = utc;
    return utc / 1000.0;
}
/*===================================================================*/
static void InfoNES_StopTimer()
{
	LOGV("InfoNES_StopTimer");
	if ( 0 != uTimerID )
	{
#ifdef WIN32
		TIMECAPS caps;
		timeKillEvent( uTimerID );
		uTimerID = 0;
		timeGetDevCaps( &caps, sizeof(caps) );
		timeEndPeriod( caps.wPeriodMin * TIMER_PER_LINE );
#else
		timer_delete( uTimerID );
		uTimerID = 0;
#endif
	}
	// Delete Critical Section Object
	LOGV("InfoNES_StopTimer finished");
}
Exemple #17
0
/*
================
Sys_Quit

This function never returns.
================
*/
void Sys_Quit(void)
{
    timeEndPeriod(1);

#if USE_CLIENT
#if USE_SYSCON
    if (dedicated && dedicated->integer) {
        FreeConsole();
    }
#endif
#elif USE_WINSVC
    if (statusHandle && !shouldExit) {
        shouldExit = SE_YES;
        Com_AbortFrame();
    }
#endif

    exit(0);
}
Exemple #18
0
void DirectSoundClose( MADDriverRec* WinMADDriver)
{
	if( WinMADDriver->lpDirectSound)
	{
		/* stop the timer */
		timeKillEvent( gwID);
		timeEndPeriod( 20);
		
		WinMADDriver->lpSwSamp->lpVtbl->Stop( WinMADDriver->lpSwSamp);
		WinMADDriver->lpSwSamp->lpVtbl->Release( WinMADDriver->lpSwSamp);
		WinMADDriver->lpSwSamp = 0L;
		
		WinMADDriver->lpDirectSoundBuffer->lpVtbl->Stop(WinMADDriver->lpDirectSoundBuffer);
  		WinMADDriver->lpDirectSoundBuffer->lpVtbl->Release(WinMADDriver->lpDirectSoundBuffer);
  
		WinMADDriver->lpDirectSound->lpVtbl->Release( WinMADDriver->lpDirectSound);
		WinMADDriver->lpDirectSound = NULL;
	}
}
void APIDataReceiver::run()
{
    timeBeginPeriod(1);
    int lastUpdate = -1;

    while(!stop)
    {
        // wait for new data and copy it into the data buffer, if data is not null
        if(waitForDataReady(TIMEOUT, data))
        {
            if(header)
            {

                // if header changes size, assume a new connection
                if(!data || dataSize != header->bufLen)
                {
                    reset();
                    dataSize = header->bufLen;
                    data = new char[dataSize];
                }
                else if(data)
                {
                    if(lastUpdate < header->sessionInfoUpdate)
                    {
                        updateStaticInfo();
                        //TODO: update semi-static data
                        lastUpdate = header->sessionInfoUpdate;
                    }

                    //TODO: update dynamic data
                }
            }
        }
        else if(!isConnected()) { // session ended
            reset();
        }
    }

    reset();
    shutdown();
    timeEndPeriod(1);
}
Exemple #20
0
/*
=================
Sys_Error
=================
*/
void Sys_Error(const char *error, ...)
{
	va_list argptr;
	char    string[1024];
#if defined (USE_WINDOWS_CONSOLE)
	MSG msg;
#endif

	va_start(argptr, error);
	Q_vsnprintf(string, sizeof(string), error, argptr);
	va_end(argptr);

#if defined (USE_WINDOWS_CONSOLE)
	Conbuf_AppendText(string);
	Conbuf_AppendText("\n");

	Sys_Splash(qfalse);
	Sys_SetErrorText(string);
	Sys_ShowConsole(1, qtrue);

	timeEndPeriod(1);

	IN_Shutdown();

	// wait for the user to quit
	while (1)
	{
		if (!GetMessage(&msg, NULL, 0, 0))
		{
			Com_Quit_f();
		}
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	Sys_DestroyConsole();
#endif

	Sys_ErrorDialog(string);

	Sys_Exit(3);
}
Exemple #21
0
void CALL HGE_Impl::System_Shutdown()
{
	System_Log("\nFinishing..");

	timeEndPeriod(1);
	_ClearQueue();
	_SoundDone();
	_GfxDone();
	if(hwnd)
	{
		//ShowWindow(hwnd, SW_HIDE);
		//SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_TOOLWINDOW);
		//ShowWindow(hwnd, SW_SHOW);
		DestroyWindow(hwnd);
		hwnd=0;
	}
	if(hInstance) UnregisterClass(WINDOW_CLASS_NAME, hInstance);

	System_Log("The End.");
}
Exemple #22
0
Rpcs3App::Rpcs3App()
{
#ifdef _WIN32
	timeBeginPeriod(1);

	WSADATA wsaData;
	WORD wVersionRequested = MAKEWORD(2, 2);
	WSAStartup(wVersionRequested, &wsaData);

	std::atexit([]
	{
		timeEndPeriod(1);
		WSACleanup();
	});
#endif

#if defined(__unix__) && !defined(__APPLE__)
	XInitThreads();
#endif
}
Exemple #23
0
// Standard DLL loader main
BOOL WINAPI DllMain(HANDLE hinstDLL, DWORD dwReason, LPVOID lpvReserved)
{
	switch (dwReason)
	{
	case DLL_PROCESS_ATTACH:
		gHInstance = (HINSTANCE)hinstDLL;
        SetupThunRTMainHook();
        timeBeginPeriod(1);
		break;
	case DLL_THREAD_ATTACH:
		break;
	case DLL_THREAD_DETACH:
		break;
	case DLL_PROCESS_DETACH:
        timeEndPeriod(1);
		CleanUp();
		break;
	}
	return TRUE;
}
Exemple #24
0
/*
=============================================================================
This routine de-intializes the system timer used for throttling the emulation
speed.
=============================================================================
*/
void deinit_throttle_timer(void)
{
#ifdef WIN32
	/* Kill the timer event */
	if (gThrottleId != 0)
		timeKillEvent(gThrottleId);

	/* End the timer period */
	timeEndPeriod(gThrottlePeriod);

	/* Destory the triggering event */
	CloseHandle(gThrottleEvent);
#else
    /* Instruct the throttle thread to terminate */
    gThrottleExit = 1;

    /* Join our throttle thread to ensure a clean shutdown */
    pthread_join(gThrottleThread, NULL);
#endif
}
Exemple #25
0
/**
 * Cleans up after system_Init() and system_Configure().
 */
void system_End(void)
{
    HWND ipcwindow;

    /* FIXME: thread-safety... */
    if (p_helper)
    {
        if( ( ipcwindow = FindWindow( 0, L"VLC ipc "VERSION ) ) != 0 )
        {
            SendMessage( ipcwindow, WM_QUIT, 0, 0 );
        }
        vlc_object_release (p_helper);
        p_helper = NULL;
    }

    timeEndPeriod(5);

    /* XXX: In theory, we should not call this if WSAStartup() failed. */
    WSACleanup();
}
Exemple #26
0
static ULONG WINAPI IDsCaptureDriverNotifyImpl_Release(PIDSDRIVERNOTIFY iface)
{
    IDsCaptureDriverNotifyImpl *This = (IDsCaptureDriverNotifyImpl *)iface;
    ULONG refCount = InterlockedDecrement(&This->ref);

    TRACE("(%p) ref was %d\n", This, refCount + 1);

    if (!refCount) {
        This->buffer->notify = NULL;
        if (This->timerID)
        {
            timeKillEvent(This->timerID);
            timeEndPeriod(DS_TIME_RES);
        }
        HeapFree(GetProcessHeap(), 0, This->notifies);
        HeapFree(GetProcessHeap(), 0, This);
        TRACE("(%p) released\n", This);
    }
    return refCount;
}
Exemple #27
0
/** Close sockets used
* @param[in] port        = port context struct
* @return 0
*/
int ecx_portt::closenic()
{
	timeEndPeriod(15);

	if (this->sockhandle != NULL)
	{
		DeleteCriticalSection(&(this->getindex_mutex));
		DeleteCriticalSection(&(this->tx_mutex));
		DeleteCriticalSection(&(this->rx_mutex));
		pcap_close(this->sockhandle);
		this->sockhandle = NULL;
	}
	if ((this->redport) && (this->redport->sockhandle != NULL))
	{
		pcap_close(this->redport->sockhandle);
		this->redport->sockhandle = NULL;
	}

	return 0;
}
static int mm_start_timer(struct qemu_alarm_timer *t)
{
    timeGetDevCaps(&mm_tc, sizeof(mm_tc));

    timeBeginPeriod(mm_tc.wPeriodMin);

    mm_timer = timeSetEvent(mm_tc.wPeriodMin,   /* interval (ms) */
                            mm_tc.wPeriodMin,   /* resolution */
                            mm_alarm_handler,   /* function */
                            (DWORD_PTR)t,       /* parameter */
                            TIME_ONESHOT | TIME_CALLBACK_FUNCTION);

    if (!mm_timer) {
        fprintf(stderr, "Failed to initialize win32 alarm timer\n");
        timeEndPeriod(mm_tc.wPeriodMin);
        return -1;
    }

    return 0;
}
Exemple #29
0
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
	const int SAMPLES = 32;

	DWORD   t1[SAMPLES], t2[SAMPLES];
	__int64 t3[SAMPLES], t4[SAMPLES], freq3, freq4;

	TIMECAPS tc;
	timeGetDevCaps(&tc, sizeof(tc));
	timeBeginPeriod(1);
	
	QueryPerformanceFrequency((LARGE_INTEGER *) & freq3); freq3 /= 1000;
	freq4 = MyQueryFrequency();							  freq4 /= 1000;

	for (int i=0; i<SAMPLES; i++)
	{
		for (int j=0; j<200; j++)	// roughly 0.2 ms to 0.5ms delay
			DeleteObject(CreateSolidBrush(0));
		
		t1[i] = GetTickCount();
		t2[i] = timeGetTime();
		QueryPerformanceCounter((LARGE_INTEGER *) & t3[i]);
		t4[i] = MyQueryCounter();
	}
	timeEndPeriod(1);

	TCHAR buffer[1024];

	sprintf(buffer, _T("tick   mm %d Khz %5.1f Mhz %5.1f Mhz\n\n"), tc.wPeriodMin, freq3/1000.0, freq4/1000.0);
	
	for (i=0; i<SAMPLES; i++)
		wsprintf(buffer+ _tcslen(buffer), "%8d %8d %8d %8d\n", 
			(t1[i]-t1[0])*1000000, 
			(t2[i]-t2[0])*1000000, 
			(int)((t3[i]-t3[0])*1000000/freq3), (int)((t4[i]-t4[0])*1000000/freq4));

	MyMessageBox(NULL, buffer, "Timer Accuracy", MB_OK);

	return 0;
}
Exemple #30
0
void ofExitCallback(){
	// controlled destruction of the mainLoop before
	// any other deinitialization
	mainLoop.reset();

	// everything should be destroyed here, except for
	// static objects


	// finish every library and subsystem
	#ifndef TARGET_EMSCRIPTEN
		ofURLFileLoaderShutdown();
	#endif

	#ifndef TARGET_NO_SOUND
		//------------------------
		// try to close engine if needed:
		ofSoundShutdown();
		//------------------------
	#endif

	// try to close quicktime, for non-linux systems:
	#if defined(OF_VIDEO_CAPTURE_QUICKTIME) || defined(OF_VIDEO_PLAYER_QUICKTIME)
	closeQuicktime();
	#endif


	//------------------------
	// try to close freeImage:
	ofCloseFreeImage();


	#ifdef WIN32_HIGH_RES_TIMING
		timeEndPeriod(1);
	#endif

	// static deinitialization happens after this finishes
	// every object should have ended by now and won't receive any
	// events
}