systemclock.c File Reference

#include "quartz_private.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include <assert.h>

Include dependency graph for systemclock.c:

Go to the source code of this file.

Classes
struct	SystemClockAdviseEntry
struct	SystemClockImpl

Macros
#define	MAX_REFTIME   (REFERENCE_TIME)(0x7FFFFFFFFFFFFFFF)
#define	ADVISE_EXIT   (WM_APP + 0)
#define	ADVISE_REMOVE   (WM_APP + 2)
#define	ADVISE_ADD_SINGLESHOT   (WM_APP + 4)
#define	ADVISE_ADD_PERIODIC   (WM_APP + 8)

Typedefs
typedef struct SystemClockAdviseEntry	SystemClockAdviseEntry
typedef struct SystemClockImpl	SystemClockImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
static SystemClockImpl *	impl_from_IReferenceClock (IReferenceClock *iface)
static void	QUARTZ_RemoveAviseEntryFromQueue (SystemClockImpl *This, SystemClockAdviseEntry *pEntry)
static void	QUARTZ_InsertAviseEntryFromQueue (SystemClockImpl *This, SystemClockAdviseEntry *pEntry, SystemClockAdviseEntry **pQueue)
static DWORD WINAPI	SystemClockAdviseThread (LPVOID lpParam)
static BOOL	SystemClockPostMessageToAdviseThread (SystemClockImpl *This, UINT iMsg)
static ULONG WINAPI	SystemClockImpl_AddRef (IReferenceClock *iface)
static HRESULT WINAPI	SystemClockImpl_QueryInterface (IReferenceClock *iface, REFIID riid, void **ppobj)
static ULONG WINAPI	SystemClockImpl_Release (IReferenceClock *iface)
static HRESULT WINAPI	SystemClockImpl_GetTime (IReferenceClock *iface, REFERENCE_TIME *pTime)
static HRESULT WINAPI	SystemClockImpl_AdviseTime (IReferenceClock *iface, REFERENCE_TIME rtBaseTime, REFERENCE_TIME rtStreamTime, HEVENT hEvent, DWORD_PTR *pdwAdviseCookie)
static HRESULT WINAPI	SystemClockImpl_AdvisePeriodic (IReferenceClock *iface, REFERENCE_TIME rtStartTime, REFERENCE_TIME rtPeriodTime, HSEMAPHORE hSemaphore, DWORD_PTR *pdwAdviseCookie)
static HRESULT WINAPI	SystemClockImpl_Unadvise (IReferenceClock *iface, DWORD_PTR dwAdviseCookie)
HRESULT	QUARTZ_CreateSystemClock (IUnknown *pUnkOuter, LPVOID *ppv)

Variables
static const IReferenceClockVtbl	SystemClock_Vtbl

Macro Definition Documentation

ADVISE_ADD_PERIODIC

#define ADVISE_ADD_PERIODIC   (WM_APP + 8)

Definition at line 94 of file systemclock.c.

ADVISE_ADD_SINGLESHOT

#define ADVISE_ADD_SINGLESHOT   (WM_APP + 4)

Definition at line 93 of file systemclock.c.

ADVISE_EXIT

#define ADVISE_EXIT   (WM_APP + 0)

Definition at line 91 of file systemclock.c.

ADVISE_REMOVE

#define ADVISE_REMOVE   (WM_APP + 2)

Definition at line 92 of file systemclock.c.

MAX_REFTIME

#define MAX_REFTIME   (REFERENCE_TIME)(0x7FFFFFFFFFFFFFFF)

Definition at line 90 of file systemclock.c.

Typedef Documentation

SystemClockAdviseEntry

typedef struct SystemClockAdviseEntry SystemClockAdviseEntry

Definition at line 29 of file systemclock.c.

SystemClockImpl

typedef struct SystemClockImpl SystemClockImpl

Function Documentation

impl_from_IReferenceClock()

static SystemClockImpl * impl_from_IReferenceClock ( IReferenceClock *  iface )

inlinestatic

Definition at line 55 of file systemclock.c.

{
    return CONTAINING_RECORD(iface, SystemClockImpl, IReferenceClock_iface);
}

Referenced by SystemClockImpl_AddRef(), SystemClockImpl_AdvisePeriodic(), SystemClockImpl_AdviseTime(), SystemClockImpl_GetTime(), SystemClockImpl_QueryInterface(), SystemClockImpl_Release(), and SystemClockImpl_Unadvise().

QUARTZ_CreateSystemClock()

HRESULT QUARTZ_CreateSystemClock	(	IUnknown *	pUnkOuter,
		LPVOID *	ppv
	)

Definition at line 377 of file systemclock.c.

                                                                     {
  SystemClockImpl* obj = NULL;
  
  TRACE("(%p,%p)\n", ppv, pUnkOuter);
  
  obj = CoTaskMemAlloc(sizeof(SystemClockImpl));
  if (NULL == obj)  {
    *ppv = NULL;
    return E_OUTOFMEMORY;
  }
  ZeroMemory(obj, sizeof(SystemClockImpl));
 
  obj->IReferenceClock_iface.lpVtbl = &SystemClock_Vtbl;
  obj->ref = 0;  /* will be inited by QueryInterface */
 
  obj->lastTimeTickCount = GetTickCount();
  InitializeCriticalSection(&obj->safe);
  obj->safe.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SystemClockImpl.safe");
 
  return SystemClockImpl_QueryInterface(&obj->IReferenceClock_iface, &IID_IReferenceClock, ppv);
}

QUARTZ_InsertAviseEntryFromQueue()

static void QUARTZ_InsertAviseEntryFromQueue ( SystemClockImpl *  This, SystemClockAdviseEntry *  pEntry, SystemClockAdviseEntry **  pQueue  )

static

Definition at line 68 of file systemclock.c.

                                                                                                                                     {
  SystemClockAdviseEntry* prev_it = NULL;
  SystemClockAdviseEntry* it = NULL;
  REFERENCE_TIME bornTime =  pEntry->rtBaseTime + pEntry->rtIntervalTime;
 
  for (it = *pQueue; NULL != it && (it->rtBaseTime + it->rtIntervalTime) < bornTime; it = it->next) {
    prev_it = it;
  }
  if (NULL == prev_it) {
    pEntry->prev = NULL;
    if (NULL != (*pQueue)) pEntry->next = (*pQueue)->next;
    /*assert( NULL == pEntry->next->prev );*/
    if (NULL != pEntry->next) pEntry->next->prev = pEntry;
    (*pQueue) = pEntry;
  } else {
    pEntry->prev = prev_it;
    pEntry->next = prev_it->next;
    prev_it->next = pEntry;
    if (NULL != pEntry->next) pEntry->next->prev = pEntry;
  }
}

Referenced by SystemClockImpl_AdvisePeriodic(), and SystemClockImpl_AdviseTime().

QUARTZ_RemoveAviseEntryFromQueue()

static void QUARTZ_RemoveAviseEntryFromQueue ( SystemClockImpl *  This, SystemClockAdviseEntry *  pEntry  )

static

Definition at line 61 of file systemclock.c.

                                                                                                    {
  if (pEntry->prev) pEntry->prev->next = pEntry->next;
  if (pEntry->next) pEntry->next->prev = pEntry->prev;
  if (This->pSingleShotAdvise == pEntry) This->pSingleShotAdvise = pEntry->next;
  if (This->pPeriodicAdvise == pEntry)    This->pPeriodicAdvise = pEntry->next;
}

Referenced by SystemClockAdviseThread(), and SystemClockImpl_Unadvise().

SystemClockAdviseThread()

static DWORD WINAPI SystemClockAdviseThread ( LPVOID  lpParam )

static

First SingleShots Advice: sorted list

send event ...

... and Release it

Now Periodics Advice: semi sorted list (sort cannot be used)

Release the semaphore ...

... and refresh time

if hwnd we suppose that is a windows event ...

set timeout to 0 to do a rescan now

hmmmm what we can do here ...

Definition at line 96 of file systemclock.c.

                                                            {
  SystemClockImpl* This = lpParam;
  DWORD timeOut = INFINITE;
  DWORD tmpTimeOut;
  MSG msg;
  HRESULT hr;
  REFERENCE_TIME curTime;
  SystemClockAdviseEntry* it = NULL;
 
  TRACE("(%p): Main Loop\n", This);
 
  while (TRUE) {
    if (timeOut > 0) MsgWaitForMultipleObjects(0, NULL, FALSE, timeOut, QS_POSTMESSAGE|QS_SENDMESSAGE|QS_TIMER);
    
    EnterCriticalSection(&This->safe);
    /*timeOut = IReferenceClock_OnTimerUpdated(This); */
    hr = IReferenceClock_GetTime(&This->IReferenceClock_iface, &curTime);
    if (FAILED(hr)) {
      timeOut = INFINITE;
      goto outrefresh;
    }
 
    it = This->pSingleShotAdvise;
    while ((NULL != it) && (it->rtBaseTime + it->rtIntervalTime) <= curTime) {
      SystemClockAdviseEntry* nextit = it->next;
      SetEvent(it->hEvent);
      QUARTZ_RemoveAviseEntryFromQueue(This, it);
      CoTaskMemFree(it);
      it = nextit;
    }
    if (NULL != it) timeOut = (DWORD) ((it->rtBaseTime + it->rtIntervalTime) - curTime) / (REFERENCE_TIME)10000;
    else timeOut = INFINITE;
 
    for (it = This->pPeriodicAdvise; NULL != it; it = it->next) {
      if (it->rtBaseTime <= curTime) {
    DWORD nPeriods = (DWORD) ((curTime - it->rtBaseTime) / it->rtIntervalTime);
    ReleaseSemaphore(it->hEvent, nPeriods, NULL);
    it->rtBaseTime += nPeriods * it->rtIntervalTime;
    /*assert( it->rtBaseTime + it->rtIntervalTime < curTime );*/
      }
      tmpTimeOut = (DWORD) ((it->rtBaseTime + it->rtIntervalTime) - curTime) / (REFERENCE_TIME)10000;
      if (timeOut > tmpTimeOut) timeOut = tmpTimeOut; 
    }
 
outrefresh:
    LeaveCriticalSection(&This->safe);
    
    while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) {
      if  (NULL != msg.hwnd) {
    TranslateMessage(&msg);
    DispatchMessageW(&msg);
      } else {
    switch (msg.message) {      
    case WM_QUIT:
    case ADVISE_EXIT:
      goto outofthread;
    case ADVISE_ADD_SINGLESHOT:
    case ADVISE_ADD_PERIODIC:
      timeOut = 0;
      break;
    case ADVISE_REMOVE:
      timeOut = INFINITE;
      break;
    default:
      ERR("Unhandled message %u. Critical Path\n", msg.message);
      break;
    }
      }
    }
  }
 
outofthread:
  TRACE("(%p): Exiting\n", This);
  return 0;
}

Referenced by SystemClockPostMessageToAdviseThread().

SystemClockImpl_AddRef()

static ULONG WINAPI SystemClockImpl_AddRef ( IReferenceClock *  iface )

static

Definition at line 202 of file systemclock.c.

                                                                   {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  ULONG ref = InterlockedIncrement(&This->ref);
 
  TRACE("(%p): AddRef from %d\n", This, ref - 1);
 
  return ref;
}

Referenced by SystemClockImpl_QueryInterface().

SystemClockImpl_AdvisePeriodic()

static HRESULT WINAPI SystemClockImpl_AdvisePeriodic ( IReferenceClock *  iface, REFERENCE_TIME  rtStartTime, REFERENCE_TIME  rtPeriodTime, HSEMAPHORE  hSemaphore, DWORD_PTR *  pdwAdviseCookie  )

static

Definition at line 301 of file systemclock.c.

                                                                                                                                                                                         {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  SystemClockAdviseEntry* pEntry = NULL;
 
  TRACE("(%p, 0x%s, 0x%s, %ld, %p)\n", This, wine_dbgstr_longlong(rtStartTime),
      wine_dbgstr_longlong(rtPeriodTime), hSemaphore, pdwAdviseCookie);
 
  if (!hSemaphore) {
    return E_INVALIDARG;
  }
  if (0 >= rtStartTime || 0 >= rtPeriodTime) {
    return E_INVALIDARG;
  }
  if (NULL == pdwAdviseCookie) {
    return E_POINTER;
  }
  pEntry = CoTaskMemAlloc(sizeof(SystemClockAdviseEntry));
  if (NULL == pEntry) {
    return E_OUTOFMEMORY;
  }
  ZeroMemory(pEntry, sizeof(SystemClockAdviseEntry));
 
  pEntry->hEvent = (HANDLE) hSemaphore;
  pEntry->rtBaseTime = rtStartTime;
  pEntry->rtIntervalTime = rtPeriodTime;
 
  EnterCriticalSection(&This->safe);
  QUARTZ_InsertAviseEntryFromQueue(This, pEntry, &This->pPeriodicAdvise);
  LeaveCriticalSection(&This->safe);
 
  SystemClockPostMessageToAdviseThread(This, ADVISE_ADD_PERIODIC);
 
  *pdwAdviseCookie = (DWORD_PTR) (pEntry);
  return S_OK;
}

SystemClockImpl_AdviseTime()

static HRESULT WINAPI SystemClockImpl_AdviseTime ( IReferenceClock *  iface, REFERENCE_TIME  rtBaseTime, REFERENCE_TIME  rtStreamTime, HEVENT  hEvent, DWORD_PTR *  pdwAdviseCookie  )

static

Definition at line 265 of file systemclock.c.

                                                                                                                                                                            {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  SystemClockAdviseEntry* pEntry = NULL;
 
  TRACE("(%p, 0x%s, 0x%s, %ld, %p)\n", This, wine_dbgstr_longlong(rtBaseTime),
      wine_dbgstr_longlong(rtStreamTime), hEvent, pdwAdviseCookie);
 
  if (!hEvent) {
    return E_INVALIDARG;
  }
  if (0 >= rtBaseTime + rtStreamTime) {
    return E_INVALIDARG;
  }
  if (NULL == pdwAdviseCookie) {
    return E_POINTER;
  }
  pEntry = CoTaskMemAlloc(sizeof(SystemClockAdviseEntry));
  if (NULL == pEntry) {
    return E_OUTOFMEMORY;
  }
  ZeroMemory(pEntry, sizeof(SystemClockAdviseEntry));
 
  pEntry->hEvent = (HANDLE) hEvent;
  pEntry->rtBaseTime = rtBaseTime + rtStreamTime;
  pEntry->rtIntervalTime = 0;
 
  EnterCriticalSection(&This->safe);
  QUARTZ_InsertAviseEntryFromQueue(This, pEntry, &This->pSingleShotAdvise);
  LeaveCriticalSection(&This->safe);
 
  SystemClockPostMessageToAdviseThread(This, ADVISE_ADD_SINGLESHOT);
 
  *pdwAdviseCookie = (DWORD_PTR) (pEntry);
  return S_OK;
}

SystemClockImpl_GetTime()

static HRESULT WINAPI SystemClockImpl_GetTime ( IReferenceClock *  iface, REFERENCE_TIME *  pTime  )

static

Definition at line 243 of file systemclock.c.

                                                                                             {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  DWORD curTimeTickCount;
  HRESULT hr = S_OK;
 
  TRACE("(%p, %p)\n", This, pTime);
 
  if (NULL == pTime) {
    return E_POINTER;
  }
 
  curTimeTickCount = GetTickCount();
 
  EnterCriticalSection(&This->safe);
  if (This->lastTimeTickCount == curTimeTickCount) hr = S_FALSE;
  This->lastRefTime += (REFERENCE_TIME) (DWORD) (curTimeTickCount - This->lastTimeTickCount) * (REFERENCE_TIME) 10000;
  This->lastTimeTickCount = curTimeTickCount;
  *pTime = This->lastRefTime;
  LeaveCriticalSection(&This->safe);
  return hr;
}

SystemClockImpl_QueryInterface()

static HRESULT WINAPI SystemClockImpl_QueryInterface ( IReferenceClock *  iface, REFIID  riid, void **  ppobj  )

static

Definition at line 211 of file systemclock.c.

                                                                                                        {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  TRACE("(%p, %s,%p)\n", This, debugstr_guid(riid), ppobj);
  
  if (IsEqualIID (riid, &IID_IUnknown) || 
      IsEqualIID (riid, &IID_IReferenceClock)) {
    SystemClockImpl_AddRef(iface);
    *ppobj = &This->IReferenceClock_iface;
    return S_OK;
  }
  
  *ppobj = NULL;
  WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppobj);
  return E_NOINTERFACE;
}

Referenced by QUARTZ_CreateSystemClock().

SystemClockImpl_Release()

static ULONG WINAPI SystemClockImpl_Release ( IReferenceClock *  iface )

static

Definition at line 227 of file systemclock.c.

                                                                    {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  ULONG ref = InterlockedDecrement(&This->ref);
  TRACE("(%p): ReleaseRef to %d\n", This, ref);
  if (ref == 0) {
    if (This->adviseThreadActive && SystemClockPostMessageToAdviseThread(This, ADVISE_EXIT)) {
      WaitForSingleObject(This->adviseThread, INFINITE);
      CloseHandle(This->adviseThread);
    }
    This->safe.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&This->safe);
    CoTaskMemFree(This);
  }
  return ref;
}

SystemClockImpl_Unadvise()

static HRESULT WINAPI SystemClockImpl_Unadvise ( IReferenceClock *  iface, DWORD_PTR  dwAdviseCookie  )

static

Definition at line 337 of file systemclock.c.

                                                                                                 {
  SystemClockImpl *This = impl_from_IReferenceClock(iface);
  SystemClockAdviseEntry* pEntry = NULL;
  SystemClockAdviseEntry* it = NULL;
  HRESULT ret = S_OK;
  TRACE("(%p, %lu)\n", This, dwAdviseCookie);
 
  pEntry = (SystemClockAdviseEntry*) dwAdviseCookie;
 
  EnterCriticalSection(&This->safe);
  for (it = This->pPeriodicAdvise; NULL != it && it != pEntry; it = it->next) ;
  if (it != pEntry) {
    for (it = This->pSingleShotAdvise; NULL != it && it != pEntry; it = it->next) ;
    if (it != pEntry) {
      ret = S_FALSE;
      goto out;
    }
  }
 
  QUARTZ_RemoveAviseEntryFromQueue(This, pEntry);
  CoTaskMemFree(pEntry);
 
  SystemClockPostMessageToAdviseThread(This, ADVISE_REMOVE);
 
out:
  LeaveCriticalSection(&This->safe);
  return ret;
}

SystemClockPostMessageToAdviseThread()

static BOOL SystemClockPostMessageToAdviseThread ( SystemClockImpl *  This, UINT  iMsg  )

static

Definition at line 182 of file systemclock.c.

                                                                                   {
  if (FALSE == This->adviseThreadActive) {
    BOOL res;
    This->adviseThread = CreateThread(NULL, 0, SystemClockAdviseThread, This, 0, &This->adviseThreadId);
    if (NULL == This->adviseThread) return FALSE;
    SetThreadPriority(This->adviseThread, THREAD_PRIORITY_TIME_CRITICAL);
    This->adviseThreadActive = TRUE;
    while(1) {
      res = PostThreadMessageW(This->adviseThreadId, iMsg, 0, 0);
      /* Let the thread creates its message queue (with MsgWaitForMultipleObjects call) by yielding and retrying */
      if (!res && (GetLastError() == ERROR_INVALID_THREAD_ID))
    Sleep(0);
      else
    break;
    }
    return res;
  }
  return PostThreadMessageW(This->adviseThreadId, iMsg, 0, 0);
}

Referenced by SystemClockImpl_AdvisePeriodic(), SystemClockImpl_AdviseTime(), SystemClockImpl_Release(), and SystemClockImpl_Unadvise().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

quartz

)

Variable Documentation

SystemClock_Vtbl

const IReferenceClockVtbl SystemClock_Vtbl

static

Initial value:

= 
{
    SystemClockImpl_QueryInterface,
    SystemClockImpl_AddRef,
    SystemClockImpl_Release,
    SystemClockImpl_GetTime,
    SystemClockImpl_AdviseTime,
    SystemClockImpl_AdvisePeriodic,
    SystemClockImpl_Unadvise
}

Definition at line 366 of file systemclock.c.

Referenced by QUARTZ_CreateSystemClock().