dlls/quartz/systemclock.c

   1 /*
   2  * Implementation of IReferenceClock
   3  *
   4  * Copyright 2004 Raphael Junqueira
   5  *
   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.
  10  *
  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.
  15  *
  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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "quartz_private.h"
  22
  23 #include "wine/debug.h"
  24 #include <assert.h>
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  27
  28 static LONG cookie_counter;
  29
  30 struct advise_sink
  31 {
  32     struct list entry;
  33     HANDLE handle;
  34     REFERENCE_TIME due_time, period;
  35     int cookie;
  36 };
  37
  38 struct system_clock
  39 {
  40     IReferenceClock IReferenceClock_iface;
  41     IUnknown IUnknown_inner;
  42     IUnknown *outer_unk;
  43     LONG refcount;
  44
  45     LONG thread_created;
  46     BOOL thread_stopped;
  47     HANDLE thread;
  48     REFERENCE_TIME last_time;
  49     CRITICAL_SECTION cs;
  50     CONDITION_VARIABLE cv;
  51
  52     struct list sinks;
  53 };
  54
  55 static REFERENCE_TIME get_current_time(void)
  56 {
  57     return (REFERENCE_TIME)timeGetTime() * 10000;
  58 }
  59
  60 static inline struct system_clock *impl_from_IUnknown(IUnknown *iface)
  61 {
  62     return CONTAINING_RECORD(iface, struct system_clock, IUnknown_inner);
  63 }
  64
  65 static HRESULT WINAPI system_clock_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out)
  66 {
  67     struct system_clock *clock = impl_from_IUnknown(iface);
  68     TRACE("clock %p, iid %s, out %p.\n", clock, debugstr_guid(iid), out);
  69
  70     if (IsEqualGUID(iid, &IID_IUnknown))
  71         *out = iface;
  72     else if (IsEqualGUID(iid, &IID_IReferenceClock))
  73         *out = &clock->IReferenceClock_iface;
  74     else
  75     {
  76         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  77         *out = NULL;
  78         return E_NOINTERFACE;
  79     }
  80
  81     IUnknown_AddRef((IUnknown *)*out);
  82     return S_OK;
  83 }
  84
  85 static ULONG WINAPI system_clock_inner_AddRef(IUnknown *iface)
  86 {
  87     struct system_clock *clock = impl_from_IUnknown(iface);
  88     ULONG refcount = InterlockedIncrement(&clock->refcount);
  89
  90     TRACE("%p increasing refcount to %lu.\n", clock, refcount);
  91
  92     return refcount;
  93 }
  94
  95 static ULONG WINAPI system_clock_inner_Release(IUnknown *iface)
  96 {
  97     struct system_clock *clock = impl_from_IUnknown(iface);
  98     ULONG refcount = InterlockedDecrement(&clock->refcount);
  99     struct advise_sink *sink, *cursor;
 100
 101     TRACE("%p decreasing refcount to %lu.\n", clock, refcount);
 102
 103     if (!refcount)
 104     {
 105         if (clock->thread)
 106         {
 107             EnterCriticalSection(&clock->cs);
 108             clock->thread_stopped = TRUE;
 109             LeaveCriticalSection(&clock->cs);
 110             WakeConditionVariable(&clock->cv);
 111             WaitForSingleObject(clock->thread, INFINITE);
 112             CloseHandle(clock->thread);
 113         }
 114
 115         LIST_FOR_EACH_ENTRY_SAFE(sink, cursor, &clock->sinks, struct advise_sink, entry)
 116         {
 117             list_remove(&sink->entry);
 118             heap_free(sink);
 119         }
 120
 121         clock->cs.DebugInfo->Spare[0] = 0;
 122         DeleteCriticalSection(&clock->cs);
 123         heap_free(clock);
 124     }
 125     return refcount;
 126 }
 127
 128 static const IUnknownVtbl system_clock_inner_vtbl =
 129 {
 130     system_clock_inner_QueryInterface,
 131     system_clock_inner_AddRef,
 132     system_clock_inner_Release,
 133 };
 134
 135 static inline struct system_clock *impl_from_IReferenceClock(IReferenceClock *iface)
 136 {
 137     return CONTAINING_RECORD(iface, struct system_clock, IReferenceClock_iface);
 138 }
 139
 140 static DWORD WINAPI SystemClockAdviseThread(void *param)
 141 {
 142     struct system_clock *clock = param;
 143     struct advise_sink *sink, *cursor;
 144     REFERENCE_TIME current_time;
 145
 146     TRACE("Starting advise thread for clock %p.\n", clock);
 147     SetThreadDescription(GetCurrentThread(), L"wine_qz_clock_advise");
 148
 149     for (;;)
 150     {
 151         DWORD timeout = INFINITE;
 152
 153         EnterCriticalSection(&clock->cs);
 154
 155         current_time = get_current_time();
 156
 157         LIST_FOR_EACH_ENTRY_SAFE(sink, cursor, &clock->sinks, struct advise_sink, entry)
 158         {
 159             if (sink->due_time <= current_time)
 160             {
 161                 if (sink->period)
 162                 {
 163                     DWORD periods = ((current_time - sink->due_time) / sink->period) + 1;
 164                     ReleaseSemaphore(sink->handle, periods, NULL);
 165                     sink->due_time += periods * sink->period;
 166                 }
 167                 else
 168                 {
 169                     SetEvent(sink->handle);
 170                     list_remove(&sink->entry);
 171                     heap_free(sink);
 172                     continue;
 173                 }
 174             }
 175
 176             timeout = min(timeout, (sink->due_time - current_time) / 10000);
 177         }
 178
 179         SleepConditionVariableCS(&clock->cv, &clock->cs, timeout);
 180         if (clock->thread_stopped)
 181         {
 182             LeaveCriticalSection(&clock->cs);
 183             return 0;
 184         }
 185         LeaveCriticalSection(&clock->cs);
 186     }
 187 }
 188
 189 static HRESULT add_sink(struct system_clock *clock, DWORD_PTR handle,
 190         REFERENCE_TIME due_time, REFERENCE_TIME period, DWORD_PTR *cookie)
 191 {
 192     struct advise_sink *sink;
 193
 194     if (!handle)
 195         return E_INVALIDARG;
 196
 197     if (!cookie)
 198         return E_POINTER;
 199
 200     if (!(sink = heap_alloc_zero(sizeof(*sink))))
 201         return E_OUTOFMEMORY;
 202
 203     sink->handle = (HANDLE)handle;
 204     sink->due_time = due_time;
 205     sink->period = period;
 206     sink->cookie = InterlockedIncrement(&cookie_counter);
 207     *cookie = sink->cookie;
 208
 209     EnterCriticalSection(&clock->cs);
 210     list_add_tail(&clock->sinks, &sink->entry);
 211     LeaveCriticalSection(&clock->cs);
 212
 213     if (!InterlockedCompareExchange(&clock->thread_created, TRUE, FALSE))
 214     {
 215         clock->thread = CreateThread(NULL, 0, SystemClockAdviseThread, clock, 0, NULL);
 216     }
 217     WakeConditionVariable(&clock->cv);
 218
 219     return S_OK;
 220 }
 221
 222 static HRESULT WINAPI SystemClockImpl_QueryInterface(IReferenceClock *iface, REFIID iid, void **out)
 223 {
 224     struct system_clock *clock = impl_from_IReferenceClock(iface);
 225     return IUnknown_QueryInterface(clock->outer_unk, iid, out);
 226 }
 227
 228 static ULONG WINAPI SystemClockImpl_AddRef(IReferenceClock *iface)
 229 {
 230     struct system_clock *clock = impl_from_IReferenceClock(iface);
 231     return IUnknown_AddRef(clock->outer_unk);
 232 }
 233
 234 static ULONG WINAPI SystemClockImpl_Release(IReferenceClock *iface)
 235 {
 236     struct system_clock *clock = impl_from_IReferenceClock(iface);
 237     return IUnknown_Release(clock->outer_unk);
 238 }
 239
 240 static HRESULT WINAPI SystemClockImpl_GetTime(IReferenceClock *iface, REFERENCE_TIME *time)
 241 {
 242     struct system_clock *clock = impl_from_IReferenceClock(iface);
 243     REFERENCE_TIME ret;
 244     HRESULT hr;
 245
 246     if (!time) {
 247         return E_POINTER;
 248     }
 249
 250     ret = get_current_time();
 251
 252     EnterCriticalSection(&clock->cs);
 253
 254     hr = (ret == clock->last_time) ? S_FALSE : S_OK;
 255     *time = clock->last_time = ret;
 256
 257     LeaveCriticalSection(&clock->cs);
 258
 259     TRACE("clock %p, time %p, returning %s.\n", clock, time, debugstr_time(ret));
 260     return hr;
 261 }
 262
 263 static HRESULT WINAPI SystemClockImpl_AdviseTime(IReferenceClock *iface,
 264         REFERENCE_TIME base, REFERENCE_TIME offset, HEVENT event, DWORD_PTR *cookie)
 265 {
 266     struct system_clock *clock = impl_from_IReferenceClock(iface);
 267
 268     TRACE("clock %p, base %s, offset %s, event %#Ix, cookie %p.\n",
 269             clock, debugstr_time(base), debugstr_time(offset), event, cookie);
 270
 271     if (base + offset <= 0)
 272         return E_INVALIDARG;
 273
 274     return add_sink(clock, event, base + offset, 0, cookie);
 275 }
 276
 277 static HRESULT WINAPI SystemClockImpl_AdvisePeriodic(IReferenceClock* iface,
 278         REFERENCE_TIME start, REFERENCE_TIME period, HSEMAPHORE semaphore, DWORD_PTR *cookie)
 279 {
 280     struct system_clock *clock = impl_from_IReferenceClock(iface);
 281
 282     TRACE("clock %p, start %s, period %s, semaphore %#Ix, cookie %p.\n",
 283             clock, debugstr_time(start), debugstr_time(period), semaphore, cookie);
 284
 285     if (start <= 0 || period <= 0)
 286         return E_INVALIDARG;
 287
 288     return add_sink(clock, semaphore, start, period, cookie);
 289 }
 290
 291 static HRESULT WINAPI SystemClockImpl_Unadvise(IReferenceClock *iface, DWORD_PTR cookie)
 292 {
 293     struct system_clock *clock = impl_from_IReferenceClock(iface);
 294     struct advise_sink *sink;
 295
 296     TRACE("clock %p, cookie %#Ix.\n", clock, cookie);
 297
 298     EnterCriticalSection(&clock->cs);
 299
 300     LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct advise_sink, entry)
 301     {
 302         if (sink->cookie == cookie)
 303         {
 304             list_remove(&sink->entry);
 305             heap_free(sink);
 306             LeaveCriticalSection(&clock->cs);
 307             return S_OK;
 308         }
 309     }
 310
 311     LeaveCriticalSection(&clock->cs);
 312
 313     return S_FALSE;
 314 }
 315
 316 static const IReferenceClockVtbl SystemClock_vtbl =
 317 {
 318     SystemClockImpl_QueryInterface,
 319     SystemClockImpl_AddRef,
 320     SystemClockImpl_Release,
 321     SystemClockImpl_GetTime,
 322     SystemClockImpl_AdviseTime,
 323     SystemClockImpl_AdvisePeriodic,
 324     SystemClockImpl_Unadvise
 325 };
 326
 327 HRESULT system_clock_create(IUnknown *outer, IUnknown **out)
 328 {
 329     struct system_clock *object;
 330
 331     TRACE("outer %p, out %p.\n", outer, out);
 332
 333     if (!(object = heap_alloc_zero(sizeof(*object))))
 334     {
 335         *out = NULL;
 336         return E_OUTOFMEMORY;
 337     }
 338
 339     object->IReferenceClock_iface.lpVtbl = &SystemClock_vtbl;
 340     object->IUnknown_inner.lpVtbl = &system_clock_inner_vtbl;
 341     object->outer_unk = outer ? outer : &object->IUnknown_inner;
 342     object->refcount = 1;
 343     list_init(&object->sinks);
 344     InitializeCriticalSectionEx(&object->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
 345     object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SystemClockImpl.cs");
 346
 347     TRACE("Created system clock %p.\n", object);
 348     *out = &object->IUnknown_inner;
 349
 350     return S_OK;
 351 }