2 * Implementation of IReferenceClock
4 * Copyright 2004 Raphael Junqueira
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #define COM_NO_WINDOWS_H
22 #include "quartz_private.h"
24 #include "wine/debug.h"
25 #include "wine/unicode.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(quartz
);
31 typedef struct SystemClockAdviseEntry SystemClockAdviseEntry
;
32 struct SystemClockAdviseEntry
{
33 SystemClockAdviseEntry
* next
;
34 SystemClockAdviseEntry
* prev
;
37 REFERENCE_TIME rtBaseTime
;
38 REFERENCE_TIME rtIntervalTime
;
41 typedef struct SystemClockImpl
{
42 IReferenceClockVtbl
*lpVtbl
;
45 /** IReferenceClock */
48 BOOL adviseThreadActive
;
49 REFERENCE_TIME lastRefTime
;
50 DWORD lastTimeTickCount
;
51 CRITICAL_SECTION safe
;
53 SystemClockAdviseEntry
* pSingleShotAdvise
;
54 SystemClockAdviseEntry
* pPeriodicAdvise
;
58 static void QUARTZ_RemoveAviseEntryFromQueue(SystemClockImpl
* This
, SystemClockAdviseEntry
* pEntry
) {
59 if (pEntry
->prev
) pEntry
->prev
->next
= pEntry
->next
;
60 if (pEntry
->next
) pEntry
->next
->prev
= pEntry
->prev
;
61 if (This
->pSingleShotAdvise
== pEntry
) This
->pSingleShotAdvise
= pEntry
->next
;
62 if (This
->pPeriodicAdvise
== pEntry
) This
->pPeriodicAdvise
= pEntry
->next
;
65 static void QUARTZ_InsertAviseEntryFromQueue(SystemClockImpl
* This
, SystemClockAdviseEntry
* pEntry
, SystemClockAdviseEntry
** pQueue
) {
66 SystemClockAdviseEntry
* prev_it
= NULL
;
67 SystemClockAdviseEntry
* it
= NULL
;
68 REFERENCE_TIME bornTime
= pEntry
->rtBaseTime
+ pEntry
->rtIntervalTime
;
70 for (it
= *pQueue
; NULL
!= it
&& (it
->rtBaseTime
+ it
->rtIntervalTime
) < bornTime
; it
= it
->next
) {
73 if (NULL
== prev_it
) {
75 if (NULL
!= (*pQueue
)) pEntry
->next
= (*pQueue
)->next
;
76 /*assert( NULL == pEntry->next->prev );*/
77 if (NULL
!= pEntry
->next
) pEntry
->next
->prev
= pEntry
;
80 pEntry
->prev
= prev_it
;
81 pEntry
->next
= prev_it
->next
;
82 prev_it
->next
= pEntry
;
83 if (NULL
!= pEntry
->next
) pEntry
->next
->prev
= pEntry
;
87 #define MAX_REFTIME (REFERENCE_TIME)(0x7FFFFFFFFFFFFFFF)
88 #define ADVISE_EXIT (WM_APP + 0)
89 #define ADVISE_REMOVE (WM_APP + 2)
90 #define ADVISE_ADD_SINGLESHOT (WM_APP + 4)
91 #define ADVISE_ADD_PERIODIC (WM_APP + 8)
93 static DWORD WINAPI
SystemClockAdviseThread(LPVOID lpParam
) {
94 SystemClockImpl
* This
= (SystemClockImpl
*) lpParam
;
95 DWORD timeOut
= INFINITE
;
99 REFERENCE_TIME curTime
;
100 SystemClockAdviseEntry
* it
= NULL
;
102 TRACE("(%p): Main Loop\n", This
);
105 if (timeOut
> 0) MsgWaitForMultipleObjects(0, NULL
, FALSE
, timeOut
, QS_POSTMESSAGE
|QS_SENDMESSAGE
|QS_TIMER
);
107 EnterCriticalSection(&This
->safe
);
108 /*timeOut = IReferenceClock_OnTimerUpdated(This); */
109 hr
= IReferenceClock_GetTime((IReferenceClock
*) This
, &curTime
);
115 /** First SingleShots Advice: sorted list */
116 for (it
= This
->pSingleShotAdvise
; NULL
!= it
&& (it
->rtBaseTime
+ it
->rtIntervalTime
) <= curTime
; it
= it
->next
) {
117 /** send event ... */
118 SetEvent((HANDLE
) it
->hEvent
);
119 /** ... and Release it */
120 QUARTZ_RemoveAviseEntryFromQueue(This
, it
);
121 HeapFree(GetProcessHeap(), 0, it
);
123 if (NULL
!= it
) timeOut
= (DWORD
) ((it
->rtBaseTime
+ it
->rtIntervalTime
) - curTime
) / (REFERENCE_TIME
)10000;
125 /** Now Periodics Advice: semi sorted list (sort cannot be used) */
126 for (it
= This
->pPeriodicAdvise
; NULL
!= it
; it
= it
->next
) {
127 if (it
->rtBaseTime
<= curTime
) {
128 DWORD nPeriods
= (DWORD
) ((curTime
- it
->rtBaseTime
) / it
->rtIntervalTime
);
129 /** Release the semaphore ... */
130 ReleaseSemaphore((HANDLE
) it
->hEvent
, nPeriods
, NULL
);
131 /** ... and refresh time */
132 it
->rtBaseTime
+= nPeriods
* it
->rtIntervalTime
;
133 /*assert( it->rtBaseTime + it->rtIntervalTime < curTime );*/
135 tmpTimeOut
= (DWORD
) ((it
->rtBaseTime
+ it
->rtIntervalTime
) - curTime
) / (REFERENCE_TIME
)10000;
136 if (timeOut
> tmpTimeOut
) timeOut
= tmpTimeOut
;
140 LeaveCriticalSection(&This
->safe
);
142 while (PeekMessageA(&msg
, NULL
, 0, 0, PM_REMOVE
)) {
143 /** if hwnd we suppose that is a windows event ... */
144 if (NULL
!= msg
.hwnd
) {
145 TranslateMessage(&msg
);
146 DispatchMessageA(&msg
);
148 switch (msg
.message
) {
153 case ADVISE_ADD_SINGLESHOT
:
154 case ADVISE_ADD_PERIODIC
:
155 /** set timeout to 0 to do a rescan now */
159 /** hmmmm what we can do here ... */
163 ERR("Unhandled message %u. Critical Path\n", msg
.message
);
171 TRACE("(%p): Exiting\n", This
);
174 /*static DWORD WINAPI SystemClockAdviseThread(LPVOID lpParam) { */
176 static BOOL
SystemClockPostMessageToAdviseThread(SystemClockImpl
* This
, UINT iMsg
) {
177 if (FALSE
== This
->adviseThreadActive
) {
179 This
->adviseThread
= CreateThread(NULL
, 0, SystemClockAdviseThread
, This
, 0, &This
->adviseThreadId
);
180 if (NULL
== This
->adviseThread
) return FALSE
;
181 SetThreadPriority(This
->adviseThread
, THREAD_PRIORITY_TIME_CRITICAL
);
182 This
->adviseThreadActive
= TRUE
;
184 res
= PostThreadMessageA(This
->adviseThreadId
, iMsg
, 0, 0);
185 /* Let the thread creates its message queue (with MsgWaitForMultipleObjects call) by yielding and retrying */
186 if (!res
&& (GetLastError() == ERROR_INVALID_THREAD_ID
))
193 return PostThreadMessageA(This
->adviseThreadId
, iMsg
, 0, 0);
196 IReferenceClockVtbl SystemClock_Vtbl
;
198 static ULONG WINAPI
SystemClockImpl_AddRef(IReferenceClock
* iface
) {
199 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
200 ULONG ref
= InterlockedIncrement(&This
->ref
);
202 TRACE("(%p): AddRef from %ld\n", This
, ref
- 1);
207 static HRESULT WINAPI
SystemClockImpl_QueryInterface(IReferenceClock
* iface
, REFIID riid
, void** ppobj
) {
208 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
209 TRACE("(%p, %s,%p)\n", This
, debugstr_guid(riid
), ppobj
);
211 if (IsEqualIID (riid
, &IID_IUnknown
) ||
212 IsEqualIID (riid
, &IID_IReferenceClock
)) {
213 SystemClockImpl_AddRef(iface
);
218 WARN("(%p, %s,%p): not found\n", This
, debugstr_guid(riid
), ppobj
);
219 return E_NOINTERFACE
;
222 static ULONG WINAPI
SystemClockImpl_Release(IReferenceClock
* iface
) {
223 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
224 ULONG ref
= InterlockedDecrement(&This
->ref
);
225 TRACE("(%p): ReleaseRef to %ld\n", This
, ref
);
227 if (SystemClockPostMessageToAdviseThread(This
, ADVISE_EXIT
)) {
228 WaitForSingleObject(This
->adviseThread
, INFINITE
);
229 CloseHandle(This
->adviseThread
);
231 DeleteCriticalSection(&This
->safe
);
232 HeapFree(GetProcessHeap(), 0, This
);
237 static HRESULT WINAPI
SystemClockImpl_GetTime(IReferenceClock
* iface
, REFERENCE_TIME
* pTime
) {
238 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
239 DWORD curTimeTickCount
;
242 TRACE("(%p, %p)\n", This
, pTime
);
248 curTimeTickCount
= GetTickCount();
250 EnterCriticalSection(&This
->safe
);
251 /** TODO: safe this not using * 10000 */
252 This
->lastRefTime
+= (REFERENCE_TIME
) (DWORD
) (curTimeTickCount
- This
->lastTimeTickCount
) * (REFERENCE_TIME
) 10000;
253 This
->lastTimeTickCount
= curTimeTickCount
;
254 LeaveCriticalSection(&This
->safe
);
256 *pTime
= This
->lastRefTime
;
257 if (This
->lastTimeTickCount
== curTimeTickCount
) hr
= S_FALSE
;
258 This
->lastTimeTickCount
= curTimeTickCount
;
262 static HRESULT WINAPI
SystemClockImpl_AdviseTime(IReferenceClock
* iface
, REFERENCE_TIME rtBaseTime
, REFERENCE_TIME rtStreamTime
, HEVENT hEvent
, DWORD_PTR
* pdwAdviseCookie
) {
263 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
264 SystemClockAdviseEntry
* pEntry
= NULL
;
266 TRACE("(%p, %lld, %lld, %ld, %p)\n", This
, rtBaseTime
, rtStreamTime
, hEvent
, pdwAdviseCookie
);
268 if ((HEVENT
) 0 == hEvent
) {
271 if (0 >= rtBaseTime
+ rtStreamTime
) {
274 if (NULL
== pdwAdviseCookie
) {
277 pEntry
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SystemClockAdviseEntry
));
278 if (NULL
== pEntry
) {
279 return E_OUTOFMEMORY
;
282 pEntry
->hEvent
= (HANDLE
) hEvent
;
283 pEntry
->rtBaseTime
= rtBaseTime
+ rtStreamTime
;
284 pEntry
->rtIntervalTime
= 0;
286 EnterCriticalSection(&This
->safe
);
287 QUARTZ_InsertAviseEntryFromQueue(This
, pEntry
, &This
->pSingleShotAdvise
);
288 LeaveCriticalSection(&This
->safe
);
290 SystemClockPostMessageToAdviseThread(This
, ADVISE_ADD_SINGLESHOT
);
292 *pdwAdviseCookie
= (DWORD_PTR
) (pEntry
);
296 static HRESULT WINAPI
SystemClockImpl_AdvisePeriodic(IReferenceClock
* iface
, REFERENCE_TIME rtStartTime
, REFERENCE_TIME rtPeriodTime
, HSEMAPHORE hSemaphore
, DWORD_PTR
* pdwAdviseCookie
) {
297 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
298 SystemClockAdviseEntry
* pEntry
= NULL
;
300 TRACE("(%p, %lld, %lld, %ld, %p)\n", This
, rtStartTime
, rtPeriodTime
, hSemaphore
, pdwAdviseCookie
);
302 if ((HSEMAPHORE
) 0 == hSemaphore
) {
305 if (0 >= rtStartTime
|| 0 >= rtPeriodTime
) {
308 if (NULL
== pdwAdviseCookie
) {
311 pEntry
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SystemClockAdviseEntry
));
312 if (NULL
== pEntry
) {
313 return E_OUTOFMEMORY
;
316 pEntry
->hEvent
= (HANDLE
) hSemaphore
;
317 pEntry
->rtBaseTime
= rtStartTime
;
318 pEntry
->rtIntervalTime
= rtPeriodTime
;
320 EnterCriticalSection(&This
->safe
);
321 QUARTZ_InsertAviseEntryFromQueue(This
, pEntry
, &This
->pPeriodicAdvise
);
322 LeaveCriticalSection(&This
->safe
);
324 SystemClockPostMessageToAdviseThread(This
, ADVISE_ADD_PERIODIC
);
326 *pdwAdviseCookie
= (DWORD_PTR
) (pEntry
);
330 static HRESULT WINAPI
SystemClockImpl_Unadvise(IReferenceClock
* iface
, DWORD_PTR dwAdviseCookie
) {
331 SystemClockImpl
*This
= (SystemClockImpl
*)iface
;
332 SystemClockAdviseEntry
* pEntry
= NULL
;
333 SystemClockAdviseEntry
* it
= NULL
;
335 TRACE("(%p, %lu)\n", This
, dwAdviseCookie
);
337 pEntry
= (SystemClockAdviseEntry
*) dwAdviseCookie
;
339 EnterCriticalSection(&This
->safe
);
340 for (it
= This
->pPeriodicAdvise
; NULL
!= it
&& it
!= pEntry
; it
= it
->next
) ;
342 for (it
= This
->pSingleShotAdvise
; NULL
!= it
&& it
!= pEntry
; it
= it
->next
) ;
349 QUARTZ_RemoveAviseEntryFromQueue(This
, pEntry
);
350 HeapFree(GetProcessHeap(), 0, pEntry
);
352 SystemClockPostMessageToAdviseThread(This
, ADVISE_REMOVE
);
355 LeaveCriticalSection(&This
->safe
);
359 IReferenceClockVtbl SystemClock_Vtbl
=
361 SystemClockImpl_QueryInterface
,
362 SystemClockImpl_AddRef
,
363 SystemClockImpl_Release
,
364 SystemClockImpl_GetTime
,
365 SystemClockImpl_AdviseTime
,
366 SystemClockImpl_AdvisePeriodic
,
367 SystemClockImpl_Unadvise
370 HRESULT
QUARTZ_CreateSystemClock(IUnknown
* pUnkOuter
, LPVOID
* ppv
) {
371 SystemClockImpl
* obj
= NULL
;
373 TRACE("(%p,%p)\n", ppv
, pUnkOuter
);
375 obj
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SystemClockImpl
));
378 return E_OUTOFMEMORY
;
380 obj
->lpVtbl
= &SystemClock_Vtbl
;
381 obj
->ref
= 0; /* will be inited by QueryInterface */
383 obj
->lastTimeTickCount
= GetTickCount();
384 InitializeCriticalSection(&obj
->safe
);
386 return SystemClockImpl_QueryInterface((IReferenceClock
*) obj
, &IID_IReferenceClock
, ppv
);