MMRESULT _StartTimer(DWORD dwTime) {
TIMECAPS caps;
MMRESULT timerid;
timeGetDevCaps(&caps, sizeof (caps));
timeBeginPeriod(caps.wPeriodMin);
timerid = timeSetEvent(dwTime, 0, _TimerFunc, 0, (UINT) TIME_PERIODIC);
return timerid;
}
void STDCALL OSInit()
{
timeBeginPeriod(1);
TIMECAPS chi;
timeGetDevCaps(&chi, sizeof(chi));
GetSystemInfo(&si);
osVersionInfo.dwOSVersionInfoSize = sizeof(osVersionInfo);
GetVersionEx(&osVersionInfo);
if (OSGetVersion() == 8)
bWindows8 = TRUE;
QueryPerformanceFrequency(&clockFreq);
QueryPerformanceCounter(&startTime);
startTick = GetTickCount();
prevElapsedTime = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pInfo = NULL, pTemp = NULL;
DWORD dwLen = 0;
if(!GetLogicalProcessorInformation(pInfo, &dwLen))
{
if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
pInfo = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(dwLen);
if(GetLogicalProcessorInformation(pInfo, &dwLen))
{
pTemp = pInfo;
DWORD dwNum = dwLen/sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
coreCount = 0;
logicalCores = 0;
for(UINT i=0; i<dwNum; i++)
{
if(pTemp->Relationship == RelationProcessorCore)
{
coreCount++;
logicalCores += CountSetBits(pTemp->ProcessorMask);
}
pTemp++;
}
}
free(pInfo);
}
}
hProfilerMutex = OSCreateMutex();
}
CDuiTimerBase::CDuiTimerBase( HWND hWnd,LPARAM lParam,WPARAM wParam,int iInterval,int iTotalTimer /*= NULL*/,bool bAutoRun /*= true*/,bool bLoop /*= false*/,bool bRevers /*= false*/ )
{
SetTimerParam(hWnd,lParam,wParam,iInterval,iTotalTimer,bAutoRun,bLoop,bRevers);
TIMECAPS tc;
if(timeGetDevCaps(&tc,sizeof(TIMECAPS))==TIMERR_NOERROR)
{
m_uTimerAccuracy=min(max(tc.wPeriodMin,1),tc.wPeriodMax);
timeBeginPeriod(m_uTimerAccuracy);
}
}
//=============================================================================
void _StopTimer(MMRESULT timerid)
{
TIMECAPS caps;
if (timerid != 0) {
timeKillEvent(timerid);
timerid = 0;
timeGetDevCaps(&caps, sizeof(caps));
timeEndPeriod(caps.wPeriodMin);
}
}
/*
=============================================================================
This routine intializes the system timer used for throttling the emulation
speed.
=============================================================================
*/
int init_throttle_timer(void)
{
#ifdef WIN32
TIMECAPS tc;
/* Get the system's multimedia timer capabilties */
timeGetDevCaps(&tc, sizeof(tc));
/* On older systems, the minimum may be 55ms. In this case, we just use 55ms as the tick */
if (tc.wPeriodMin > 50)
{
gThrottlePeriod = tc.wPeriodMin;
gThrottleTerminalCount = 1000 / gThrottlePeriod;
}
else if (tc.wPeriodMin <= 10)
{
/* We don't need 10ms of resolution. Let's use 20ms instead */
gThrottlePeriod = 50;
/* Set TC for 50 counts = 1sec */
gThrottleTerminalCount = 20;
}
/* Setup the throttle event for signalling */
gThrottleEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
InitializeCriticalSection(&gThrottleCritSect);
/* Calculate the period, Throttle Delta time and setup the timer */
gThrottleDelta = gTargetFrequency * gThrottlePeriod / 1000;
if (timeBeginPeriod(gThrottlePeriod) == TIMERR_NOCANDO)
return FALSE;
gThrottleId = timeSetEvent(gThrottlePeriod, tc.wPeriodMin, ThrottleProc,
0, TIME_PERIODIC );
#else
/* We don't need 10ms of resolution. Let's use 20ms instead */
gThrottlePeriod = 40;
/* Set TC for 50 counts = 1sec */
gThrottleTerminalCount = 25;
gThrottlePeriodCount = 0;
gThrottleDelta = gTargetFrequency * gThrottlePeriod / 1000;
gThrottleCycles = cycles + (gThrottleDelta << 1);
// Initialize thread processing
pthread_mutex_init(&gThrottleLock, NULL);
pthread_create(&gThrottleThread, NULL, ThrottlePeriodProc, NULL);
sem_init(&gThrottleEvent, 0, 0);
#endif
return 1;
}
/*
By default in 2000/XP, the timeGetTime call is set to some resolution
between 10-15 ms query for the range of value periods and then set timer
to the lowest possible. Note: MUST make call to corresponding
CleanupMillisTimer
*/
void SetupMillisTimer(void) {
TIMECAPS timeCaps;
timeGetDevCaps(&timeCaps, sizeof(TIMECAPS));
if (timeBeginPeriod(timeCaps.wPeriodMin) == TIMERR_NOCANDO) {
fprintf(stderr,"WARNING: Cannot set timer precision. Not sure what precision we're getting!\n");
}else {
timerRes = timeCaps.wPeriodMin;
fprintf(stderr,"(* Set timer resolution to %d ms. *)\n",timeCaps.wPeriodMin);
}
}
int main(int argc,char**argv){
ARParam cparam;
ARParam wparam;
int xsize,ysize;
glutInit(&argc,argv);
if(arVideoOpen(vconf_name)<0){
puts("ビデオデバイスエラー");
return -1;
}
if(arVideoInqSize(&xsize,&ysize) < 0)return -1;
if(arParamLoad(cparam_name,1,&wparam)< 0){
puts("パラメータ読み込み失敗");
return -1;
}
arParamChangeSize(&wparam,xsize,ysize,&cparam);
arInitCparam(&cparam);
nyobj = nyar_NyARTransMat_O2_create(&cparam);
if( (patt_id=arLoadPatt(pattern_name)) < 0){
puts("パターン読み込みエラー");
return -1;
}
argInit(&cparam, 1.0, 0, 0, 0, 0);
mqoInit();
if(Data_Load()==-1)
return -1;
arVideoCapStart();
InitGame();
arUtilTimerReset();
#ifdef _WIN32
TIMECAPS Caps;
timeGetDevCaps(&Caps, sizeof(TIMECAPS)); // 性能取得
timeBeginPeriod(Caps.wPeriodMin);
#endif
argMainLoop(MouseEvent,KeyEvent,MainLoop);
#ifdef _WIN32
timeEndPeriod(Caps.wPeriodMin);
#endif
nyar_NyARTransMat_O2_free(nyobj);
return 0;
}
static UINT mwGetMinTimerResolution(void)
{
TIMECAPS tc;
if (timeGetDevCaps(&tc, sizeof(tc)) != TIMERR_NOERROR)
{
mw_printf("Failed to get timer resolution\n");
return 0;
}
/* target 1-millisecond target resolution */
return MIN(MAX(tc.wPeriodMin, 1), tc.wPeriodMax);
}
void baseTimer::timerThread()
{
GJV_thread::setThreadName( "hires timer" );
currTick = 0;
basetick = GetTickCount();
TIMECAPS tc;
if ( timeGetDevCaps( &tc, sizeof( TIMECAPS ) ) != TIMERR_NOERROR )
{
// Error; application can't continue.
MessageBox( 0, "Timer", "GetDevCaps", MB_ICONERROR | MB_OK );
}
UINT wTimerRes = std::min( std::max( tc.wPeriodMin, TARGET_RESOLUTION ), tc.wPeriodMax );
timeBeginPeriod( wTimerRes );
MMRESULT timeEventId = timeSetEvent( TIMER_INTERVAL, 0, intrTick, 0, TIME_PERIODIC );
hTimerThreadCloseEvent = CreateEvent(
NULL, // no security attributes
TRUE, // manual reset event
FALSE, // not-signalled
NULL ); // no name
while ( 1 )
{
// Wait for request to close or for a read thread to terminate.
DWORD dwWait = WaitForSingleObject( hTimerThreadCloseEvent, 1000 );
if ( dwWait == WAIT_TIMEOUT )
continue;
CloseHandle( hTimerThreadCloseEvent );
if ( timeEventId )
{
timeKillEvent( timeEventId );
timeEventId = 0;
}
if ( wTimerRes )
{
timeEndPeriod( wTimerRes );
wTimerRes = 0;
}
return ;
}
}
// By default in 2000/XP, the timeGetTime call is set to some resolution
// between 10-15 ms query for the range of value periods and then set timer
// to the lowest possible. Note: MUST make call to corresponding
// CleanupMillisTimer
void SetupMillisTimer(void) {
TIMECAPS timeCaps;
timeGetDevCaps(&timeCaps, sizeof(TIMECAPS));
if (timeBeginPeriod(timeCaps.wPeriodMin) == TIMERR_NOCANDO) {
std::cerr << "WARNING: Cannot set timer precision. Not sure what precision we're getting!\n";
}
else {
timerRes = timeCaps.wPeriodMin;
std::cout << "(* Set timer resolution to " << timeCaps.wPeriodMin << " ms. *)\n";
}
}
BOOL
StartIOManager(void)
{
HANDLE hExit;
WorkQueue* wq;
UINT sleepResolution;
TIMECAPS timecaps;
MMRESULT mmresult;
mmresult = timeGetDevCaps(&timecaps, sizeof(timecaps));
if (mmresult != MMSYSERR_NOERROR) {
return false;
}
sleepResolution = timecaps.wPeriodMin;
mmresult = timeBeginPeriod(sleepResolution);
if (mmresult != MMSYSERR_NOERROR) {
return false;
}
wq = NewWorkQueue();
if ( !wq ) return false;
ioMan = (IOManagerState*)malloc(sizeof(IOManagerState));
if (!ioMan) {
FreeWorkQueue(wq);
return false;
}
/* A manual-reset event */
hExit = CreateEvent ( NULL, true, false, NULL );
if ( !hExit ) {
FreeWorkQueue(wq);
free(ioMan);
return false;
}
ioMan->hExitEvent = hExit;
InitializeCriticalSection(&ioMan->manLock);
ioMan->workQueue = wq;
ioMan->numWorkers = 0;
ioMan->workersIdle = 0;
ioMan->queueSize = 0;
ioMan->requestID = 1;
InitializeCriticalSection(&ioMan->active_work_lock);
ioMan->active_work_items = NULL;
ioMan->sleepResolution = sleepResolution;
return true;
}
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine,int nCmdShow )
{
MSG msg;
if( !initApplication(hInstance) ) return FALSE;
HANDLE hMutex = CreateMutex(NULL,NULL,className);
if(ERROR_ALREADY_EXISTS == GetLastError())return FALSE;
HANDLE hAccel = LoadAccelerators( hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR) );
CoInitialize(NULL);
readProfile();
if( !OpenPackFile() ) return FALSE;
if( !InitInstance(hInstance,nCmdShow) ) return FALSE;
SystemInit();
WINNLSEnableIME(sysInf.hWnd,FALSE);
TIMECAPS tc;
timeGetDevCaps(&tc,sizeof(tc));
timeBeginPeriod(tc.wPeriodMin);
while(FALSE==sysInf.bGameEnd){
BOOL bGotMsg;
if(sysInf.bIsActive || lpMovie || lpStaffRoll){
bGotMsg = PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE);
}else{
bGotMsg = GetMessage( &msg, NULL, 0U, 0U );
}
if(bGotMsg){
if(TranslateAccelerator( sysInf.hWnd, (HACCEL)hAccel, &msg ))continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(sysInf.bIsActive || sysInf.execMode==movie_mode || lpStaffRoll){
mainLoop();
}
}
WINNLSEnableIME(sysInf.hWnd,TRUE);
timeEndPeriod(tc.wPeriodMin);
writeProfile();
cleanup();
CoUninitialize();
CloseHandle(hMutex);
if(CheckWinExec()){
WinExec2( str_winpath, str_winexec );
}
return msg.wParam;
} // WinMain
void
ioInitTime()
{
# if !defined(_WIN32_WCE)
TIMECAPS tCaps;
dwTimerPeriod = 0;
if(timeGetDevCaps(&tCaps,sizeof(tCaps)) != 0)
return;
dwTimerPeriod = tCaps.wPeriodMin;
if (timeBeginPeriod(dwTimerPeriod) != 0)
return;
# endif
}
//==============================================================================================
// ゲームメイン処理
//==============================================================================================
void GameMain(void) {
TIMECAPS Caps;
timeGetDevCaps(&Caps, sizeof(TIMECAPS)); // 性能取得
timeBeginPeriod(Caps.wPeriodMin); // 設定
HDC hDC_Back = CreateEmptyBMP(hDC_Wnd, pWid, pHei);
HDC hDC_Wheel = LoadBMPfromFile(hDC_Wnd, TEXT("wheel.bmp"));
HDC hDC_Block = LoadBMPfromResourceSTR(hDC_Wnd, hInst, TEXT("IDB_BLOCKIDB_BLOCK"));
HDC hDC_org = LoadBMPfromResourceSTR(hDC_Wnd, hInst, TEXT("IDB_ORG"));
HDC hDC_Mask = CreateMask(hDC_org, RGB(0, 0, 0));
HANDLE hfile;
DWORD file_size, read_byte;
mciSendString(_T("close BGM"), NULL, 0, NULL); // （前回ちゃんと閉じられなかったかも…）
mciSendString(_T("open SHOOT!.mid type sequencer alias BGM"), NULL, 0, NULL); // 開く
TCHAR BGMStatus[256] = { 0 };
mciSendString(_T("status BGM mode"), BGMStatus, 256, NULL); // 状態の取得
if (lstrcmp(BGMStatus, TEXT("stopped")) == 0) {
mciSendString(TEXT("play BGM from 0"), NULL, 0, NULL); // 停止中なら演奏
}
Sleep(15000);
LPCTSTR Sound = LoadSound(_T("notify.wav"));
PlaySound(Sound, NULL, SND_ASYNC | SND_MEMORY);
//メインループ
while (!EndFlag) {
const DWORD StartTime = timeGetTime();
//～ ゲーム処理いろいろ ～
//PatBlt(hDC_Back, 0, 0, pWid, pHei, WHITENESS);
BitBlt(hDC_Back, 0, 0, 32, 32, hDC_Wheel, 0, 0, SRCCOPY);
BitBlt(hDC_Back, 64, 0, 32, 32, hDC_Block, 0, 0, SRCCOPY);
//SpriteBlt(hDC_Back, 32, 0, 32, 32, hDC_org, 0, 0, hDC_Mask);
BitBlt(hDC_Wnd, 0, 0, pWid, pHei, hDC_Back, 0, 0, SRCCOPY);
const DWORD PassTime = timeGetTime() - StartTime; // 経過時間の計算
(1000 / FPS > PassTime) ? Wait(1000 / FPS - PassTime) : Wait(0); // 待つ。
mciSendString(TEXT("status BGM mode"), BGMStatus, 256, NULL); // 状態の取得
if (lstrcmp(BGMStatus, TEXT("stopped")) == 0) {
mciSendString(TEXT("play BGM from 0"), NULL, 0, NULL); // 停止中なら演奏
}
FPSCount(&fps); // FPS の計測
}
timeEndPeriod(Caps.wPeriodMin); // 後処理
HeapFree(GetProcessHeap(), 0, (LPVOID)Sound); // 解放
DeleteDC(hDC_Wheel);
DeleteDC(hDC_Block);
}
void newfunc_newhandler08_init(void)
{
TIMECAPS tc;
timeGetDevCaps(&tc,sizeof(tc));
if(tc.wPeriodMin<1)
tc.wPeriodMin=1;
int08_timer_period=(long)(1000.0/(float)INT08_CYCLES_NEW);
if(int08_timer_period<=tc.wPeriodMin)
int08_timer_period=tc.wPeriodMin;
timeBeginPeriod(int08_timer_period);
#ifndef MPXPLAY_USE_SMP
{
HANDLE curr_process=GetCurrentProcess();
if(curr_process)
SetProcessAffinityMask(curr_process,MPXPLAY_THREAD_AFFINITY_MASK);
}
#endif
if(!int08_timer_thread_handle){
int08_timer_thread_handle=(HANDLE)_beginthreadex(NULL,0,(void *)newhandler_08_timer_thread,NULL,CREATE_SUSPENDED,NULL);
if(int08_timer_thread_handle){
SetThreadPriority(int08_timer_thread_handle,THREAD_PRIORITY_HIGHEST);
SetSecurityInfo(int08_timer_thread_handle,SE_KERNEL_OBJECT,MPXPLAY_INT08THREAD_RIGHTS,NULL,NULL,NULL,NULL);
#ifndef MPXPLAY_USE_SMP
SetThreadAffinityMask(int08_timer_thread_handle,MPXPLAY_THREAD_AFFINITY_MASK);
#endif
ResumeThread(int08_timer_thread_handle);
}else{
}
}
if(!int08_thread_handle){
int08_thread_handle=(HANDLE)_beginthreadex(NULL,0,(void *)newhandler_08_thread,NULL,CREATE_SUSPENDED,NULL);
if(int08_thread_handle){
SetThreadPriority(int08_thread_handle,THREAD_PRIORITY_HIGHEST);
SetSecurityInfo(int08_thread_handle,SE_KERNEL_OBJECT,MPXPLAY_INT08THREAD_RIGHTS,NULL,NULL,NULL,NULL);
#ifndef MPXPLAY_USE_SMP
SetThreadAffinityMask(int08_thread_handle,MPXPLAY_THREAD_AFFINITY_MASK);
#endif
ResumeThread(int08_thread_handle);
}else{
}
}
}
double getTimeSeconds(void)
{
static char init = 0;
static TIMECAPS timerInfo;
if(!init)
{
timeGetDevCaps(&timerInfo, sizeof(TIMECAPS));
timeBeginPeriod(timerInfo.wPeriodMin);
init = 1;
}
return (double) (timeGetTime() / 1000.0);
}
void vlc_timer_schedule (vlc_timer_t timer, bool absolute,
mtime_t value, mtime_t interval)
{
#ifndef UNDER_CE
if (timer->handle != INVALID_HANDLE_VALUE)
{
DeleteTimerQueueTimer (NULL, timer->handle, NULL);
timer->handle = INVALID_HANDLE_VALUE;
}
#else
if (timer->id)
{
timeKillEvent (timer->id);
timer->id = 0;
timer->interval = 0;
}
#endif
if (value == 0)
return; /* Disarm */
if (absolute)
value -= mdate ();
value = (value + 999) / 1000;
interval = (interval + 999) / 1000;
#ifndef UNDER_CE
if (!CreateTimerQueueTimer (&timer->handle, NULL, vlc_timer_do, timer,
value, interval, WT_EXECUTEDEFAULT))
#else
TIMECAPS caps;
timeGetDevCaps (&caps, sizeof(caps));
unsigned delay = value;
delay = __MAX(delay, caps.wPeriodMin);
delay = __MIN(delay, caps.wPeriodMax);
unsigned event = TIME_ONESHOT;
if (interval == delay)
event = TIME_PERIODIC;
else if (interval)
timer->interval = interval;
timer->id = timeSetEvent (delay, delay / 20, vlc_timer_do, (DWORD) timer,
event);
if (!timer->id)
#endif
abort ();
}
// A derived class may supply a hThreadEvent if it has its own thread that will take care
// of calling the schedulers Advise method. (Refere to CBaseReferenceClock::AdviseThread()
// to see what such a thread has to do.)
CBaseReferenceClock::CBaseReferenceClock( TCHAR *pName, LPUNKNOWN pUnk, HRESULT *phr, CAMSchedule * pShed )
: CUnknown( pName, pUnk )
, m_rtLastGotTime(0)
, m_TimerResolution(0)
, m_bAbort( FALSE )
, m_pSchedule( pShed ? pShed : new CAMSchedule(CreateEvent(NULL, FALSE, FALSE, NULL)) )
, m_hThread(0) {
ASSERT(m_pSchedule);
if(!m_pSchedule) {
*phr = E_OUTOFMEMORY;
}
else {
// Set up the highest resolution timer we can manage
TIMECAPS tc;
m_TimerResolution = (TIMERR_NOERROR == timeGetDevCaps(&tc, sizeof(tc)))
? tc.wPeriodMin : 1;
timeBeginPeriod(m_TimerResolution);
/* Initialise our system times - the derived clock should set the right values */
m_dwPrevSystemTime = timeGetTime();
m_rtPrivateTime = (UNITS / MILLISECONDS) * m_dwPrevSystemTime;
#ifdef PERF
m_idGetSystemTime = MSR_REGISTER(TEXT("CBaseReferenceClock::GetTime"));
#endif
if(!pShed) {
DWORD ThreadID;
m_hThread = ::CreateThread(NULL, // Security attributes
(DWORD) 0, // Initial stack size
AdviseThreadFunction, // Thread start address
(LPVOID) this, // Thread parameter
(DWORD) 0, // Creation flags
&ThreadID); // Thread identifier
if(m_hThread) {
SetThreadPriority(m_hThread, THREAD_PRIORITY_TIME_CRITICAL);
}
else {
*phr = E_FAIL;
EXECUTE_ASSERT(CloseHandle(m_pSchedule->GetEvent()));
delete m_pSchedule;
}
}
}
}
TimeSource * TimeSource::get()
{
if (!m_pTimeSource) {
#ifdef _WIN32
TIMECAPS tc;
UINT wTimerRes;
MMRESULT err = timeGetDevCaps(&tc, sizeof(TIMECAPS));
AVG_ASSERT(err == TIMERR_NOERROR);
wTimerRes = max(tc.wPeriodMin, 1);
timeBeginPeriod(wTimerRes);
#endif
m_pTimeSource = new TimeSource;
}
return m_pTimeSource;
}
NativeTimer(){
MMRESULT result = timeGetDevCaps(&timeCaps_,sizeof(TIMECAPS));
if( result != TIMERR_NOERROR ){
timeCaps_.wPeriodMin = 1;
isUseTimeGetTime_ = false;
return;
}
if( timeCaps_.wPeriodMin >= 10 ){
timeCaps_.wPeriodMin = 1;
isUseTimeGetTime_ = false;
}else{
::timeBeginPeriod( timeCaps_.wPeriodMin );
isUseTimeGetTime_ = true;
}
}
static void get_min_period(void)
{
TIMECAPS tc;
MMRESULT result = timeGetDevCaps(&tc, sizeof(TIMECAPS));
switch(result) {
case TIMERR_NOERROR:
DIAGNOSTIC(4,"time caps: %d min, %d max",tc.wPeriodMin,tc.wPeriodMax);
break;
case TIMERR_STRUCT:
error("timeGetDevCaps() failed");
default:
error ("timeGetDevCaps() returned %d",result);
}
time_resolution = tc.wPeriodMin;
}
static BOOL WINAPI prvEndProcess( DWORD dwCtrlType )
{
TIMECAPS xTimeCaps;
( void ) dwCtrlType;
if( timeGetDevCaps( &xTimeCaps, sizeof( xTimeCaps ) ) == MMSYSERR_NOERROR )
{
/* Match the call to timeBeginPeriod( xTimeCaps.wPeriodMin ) made when
the process started with a timeEndPeriod() as the process exits. */
timeEndPeriod( xTimeCaps.wPeriodMin );
}
return pdPASS;
}
void sleepImpl(Time time)
{
// Get the supported timer resolutions on this system
TIMECAPS tc;
timeGetDevCaps(&tc, sizeof(TIMECAPS));
// Set the timer resolution to the minimum for the Sleep call
timeBeginPeriod(tc.wPeriodMin);
// Wait...
::Sleep(time.asMilliseconds());
// Reset the timer resolution back to the system default
timeEndPeriod(tc.wPeriodMin);
}
uint32_t gvl_get_ticks()
{
static int setup = 0;
if(!setup)
{
TIMECAPS caps;
setup = 1;
if(timeGetDevCaps(&caps, sizeof(caps)) == TIMERR_NOERROR)
{
timeBeginPeriod(min(max(caps.wPeriodMin, 1), caps.wPeriodMax));
}
}
return (uint32_t)(timeGetTime());
}
void NativeSoundMix::NativeConstruct()
{
hWaveOut = 0;
isOpen = false;
memset( &waveHDR, 0, sizeof( WAVEHDR ) * MAX_SOUND_BUFFERS );
InitializeCriticalSection(&playLock);
playThread = 0;
playEvent = CreateEvent(0, false, false, 0);
// Set the timer interval
TIMECAPS tc;
timeGetDevCaps(&tc, sizeof(tc));
period = max(1, (int)tc.wPeriodMin); // get the best possible resolution...
timeBeginPeriod(period);
}
SERVER_EXPORT void InitTime()
{
QueryPerformanceFrequency(&_jack_freq);
TIMECAPS caps;
if (timeGetDevCaps(&caps, sizeof(TIMECAPS)) != TIMERR_NOERROR) {
jack_error("InitTime : could not get timer device");
} else {
gPeriod = caps.wPeriodMin;
if (timeBeginPeriod(gPeriod) != TIMERR_NOERROR) {
jack_error("InitTime : could not set minimum timer");
gPeriod = 0;
} else {
jack_info("InitTime : multimedia timer resolution set to %d milliseconds", gPeriod);
}
}
}
StopWatch::StopWatch()
{
QueryPerformanceFrequency( &frequency ) ;
#define TARGET_RESOLUTION 1 // 1-millisecond target resolution
TIMECAPS tc;
if (timeGetDevCaps(&tc, sizeof(TIMECAPS)) != TIMERR_NOERROR)
{
// Error; application can't continue.
}
wTimerRes = min(max(tc.wPeriodMin, TARGET_RESOLUTION), tc.wPeriodMax);
timeBeginPeriod(wTimerRes);
}
CMackieControlMaster::CMackieControlMaster()
{
// TRACE("CMackieControlMaster::CMackieControlMaster()\n");
m_bExpectedDeviceType = 0x14;
m_bWasInEQFreqGainMode = false;
m_eCurrentTransportDir = DIR_FORWARD;
m_fTransportTimeout = 0;
m_bKeyRepeatKey = 0;
m_fKeyRepeatTimeout = 0;
int n = 0;
// Wire everything up together
for (n = 0; n < NUM_VSELECT_DISPLAY_CELLS; n++)
m_cVSelectDisplay[n].Setup(this, 0x0A + NUM_VSELECT_DISPLAY_CELLS - n - 1);
for (n = 0; n < NUM_TIME_CODE_DISPLAY_CELLS; n++)
m_cTimeCodeDisplay[n].Setup(this, NUM_TIME_CODE_DISPLAY_CELLS - n - 1);
m_HwMasterFader.Setup(this, 8);
CCriticalSectionAuto csa(m_cState.GetCS());
// Default user key and foot bindings
m_cState.SetUserFunctionKey(0, CMD_VIEW_NEW_EXPLORER);
m_cState.SetUserFunctionKey(1, CMD_VIEW_NEW_LOOP_CONSTR);
m_cState.SetUserFunctionKey(2, CMD_VIEW_CONSOLE);
m_cState.SetUserFunctionKey(3, CMD_VIEW_NEW_EVENT_LIST);
m_cState.SetUserFunctionKey(4, CMD_VIEW_NEW_PIANO_ROLL);
m_cState.SetUserFunctionKey(5, CMD_VIEW_VIDEO);
m_cState.SetUserFunctionKey(6, CMD_VIEW_NEW_STAFF);
m_cState.SetUserFunctionKey(7, CMD_VIEW_NEW_LYRICS);
m_cState.SetUserFootSwitch(0, CMD_REALTIME_PLAY);
m_cState.SetUserFootSwitch(1, CMD_REALTIME_RECORD);
TIMECAPS timeDevCaps;
timeGetDevCaps(&timeDevCaps, sizeof(timeDevCaps));
TRACE("timeDevCaps.wPeriodMin = %d\n", timeDevCaps.wPeriodMin);
m_wTransportTimerPeriod = max(timeDevCaps.wPeriodMin, 10);
m_wKeyRepeatTimerPeriod = max(timeDevCaps.wPeriodMin, 10);
m_bTransportTimerActive = false;
m_bKeyRepeatTimerActive = false;
}
CSpeedLimiter::CSpeedLimiter()
{
m_Frames = 0;
m_LastTime = 0;
m_Speed = 60;
m_BaseSpeed = 60;
m_Ratio = 1000.0F / (float)m_Speed;
#ifdef _WIN32
TIMECAPS Caps;
timeGetDevCaps(&Caps, sizeof(Caps));
if (timeBeginPeriod(Caps.wPeriodMin) == TIMERR_NOCANDO)
{
g_Notify->DisplayError("Error during timer begin");
}
#endif
}
ArtWindow::ArtWindow()
{
TIMECAPS tc;
UINT wTimerRes;
if (timeGetDevCaps(&tc, sizeof(TIMECAPS)) != TIMERR_NOERROR)
{
console::error("Smooth Album Art: Timer error");
// TODO: handle error
}
wTimerRes = min(max(tc.wPeriodMin, 1), tc.wPeriodMax);
timeBeginPeriod(wTimerRes);
TimerQueue = NULL;
RepaintTimer = NULL;
}
