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
 148     for (;;)
 149     {
 150         DWORD timeout = INFINITE;
 151
 152         EnterCriticalSection(&clock->cs);
 153
 154         current_time = get_current_time();
 155
 156         LIST_FOR_EACH_ENTRY_SAFE(sink, cursor, &clock->sinks, struct advise_sink, entry)
 157         {
 158             if (sink->due_time <= current_time)
 159             {
 160                 if (sink->period)
 161                 {
 162                     DWORD periods = ((current_time - sink->due_time) / sink->period) + 1;
 163                     ReleaseSemaphore(sink->handle, periods, NULL);
 164                     sink->due_time += periods * sink->period;
 165                 }
 166                 else
 167                 {
 168                     SetEvent(sink->handle);
 169                     list_remove(&sink->entry);
 170                     heap_free(sink);
 171                     continue;
 172                 }
 173             }
 174
 175             timeout = min(timeout, (sink->due_time - current_time) / 10000);
 176         }
 177
 178         SleepConditionVariableCS(&clock->cv, &clock->cs, timeout);
 179         if (clock->thread_stopped)
 180         {
 181             LeaveCriticalSection(&clock->cs);
 182             return 0;
 183         }
 184         LeaveCriticalSection(&clock->cs);
 185     }
 186 }
 187
 188 static HRESULT add_sink(struct system_clock *clock, DWORD_PTR handle,
 189         REFERENCE_TIME due_time, REFERENCE_TIME period, DWORD_PTR *cookie)
 190 {
 191     struct advise_sink *sink;
 192
 193     if (!handle)
 194         return E_INVALIDARG;
 195
 196     if (!cookie)
 197         return E_POINTER;
 198
 199     if (!(sink = heap_alloc_zero(sizeof(*sink))))
 200         return E_OUTOFMEMORY;
 201
 202     sink->handle = (HANDLE)handle;
 203     sink->due_time = due_time;
 204     sink->period = period;
 205     sink->cookie = InterlockedIncrement(&cookie_counter);
 206     *cookie = sink->cookie;
 207
 208     EnterCriticalSection(&clock->cs);
 209     list_add_tail(&clock->sinks, &sink->entry);
 210     LeaveCriticalSection(&clock->cs);
 211
 212     if (!InterlockedCompareExchange(&clock->thread_created, TRUE, FALSE))
 213     {
 214         clock->thread = CreateThread(NULL, 0, SystemClockAdviseThread, clock, 0, NULL);
 215     }
 216     WakeConditionVariable(&clock->cv);
 217
 218     return S_OK;
 219 }
 220
 221 static HRESULT WINAPI SystemClockImpl_QueryInterface(IReferenceClock *iface, REFIID iid, void **out)
 222 {
 223     struct system_clock *clock = impl_from_IReferenceClock(iface);
 224     return IUnknown_QueryInterface(clock->outer_unk, iid, out);
 225 }
 226
 227 static ULONG WINAPI SystemClockImpl_AddRef(IReferenceClock *iface)
 228 {
 229     struct system_clock *clock = impl_from_IReferenceClock(iface);
 230     return IUnknown_AddRef(clock->outer_unk);
 231 }
 232
 233 static ULONG WINAPI SystemClockImpl_Release(IReferenceClock *iface)
 234 {
 235     struct system_clock *clock = impl_from_IReferenceClock(iface);
 236     return IUnknown_Release(clock->outer_unk);
 237 }
 238
 239 static HRESULT WINAPI SystemClockImpl_GetTime(IReferenceClock *iface, REFERENCE_TIME *time)
 240 {
 241     struct system_clock *clock = impl_from_IReferenceClock(iface);
 242     REFERENCE_TIME ret;
 243     HRESULT hr;
 244
 245     if (!time) {
 246         return E_POINTER;
 247     }
 248
 249     ret = get_current_time();
 250
 251     EnterCriticalSection(&clock->cs);
 252
 253     hr = (ret == clock->last_time) ? S_FALSE : S_OK;
 254     *time = clock->last_time = ret;
 255
 256     LeaveCriticalSection(&clock->cs);
 257
 258     TRACE("clock %p, time %p, returning %s.\n", clock, time, debugstr_time(ret));
 259     return hr;
 260 }
 261
 262 static HRESULT WINAPI SystemClockImpl_AdviseTime(IReferenceClock *iface,
 263         REFERENCE_TIME base, REFERENCE_TIME offset, HEVENT event, DWORD_PTR *cookie)
 264 {
 265     struct system_clock *clock = impl_from_IReferenceClock(iface);
 266
 267     TRACE("clock %p, base %s, offset %s, event %#Ix, cookie %p.\n",
 268             clock, debugstr_time(base), debugstr_time(offset), event, cookie);
 269
 270     if (base + offset <= 0)
 271         return E_INVALIDARG;
 272
 273     return add_sink(clock, event, base + offset, 0, cookie);
 274 }
 275
 276 static HRESULT WINAPI SystemClockImpl_AdvisePeriodic(IReferenceClock* iface,
 277         REFERENCE_TIME start, REFERENCE_TIME period, HSEMAPHORE semaphore, DWORD_PTR *cookie)
 278 {
 279     struct system_clock *clock = impl_from_IReferenceClock(iface);
 280
 281     TRACE("clock %p, start %s, period %s, semaphore %#Ix, cookie %p.\n",
 282             clock, debugstr_time(start), debugstr_time(period), semaphore, cookie);
 283
 284     if (start <= 0 || period <= 0)
 285         return E_INVALIDARG;
 286
 287     return add_sink(clock, semaphore, start, period, cookie);
 288 }
 289
 290 static HRESULT WINAPI SystemClockImpl_Unadvise(IReferenceClock *iface, DWORD_PTR cookie)
 291 {
 292     struct system_clock *clock = impl_from_IReferenceClock(iface);
 293     struct advise_sink *sink;
 294
 295     TRACE("clock %p, cookie %#Ix.\n", clock, cookie);
 296
 297     EnterCriticalSection(&clock->cs);
 298
 299     LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct advise_sink, entry)
 300     {
 301         if (sink->cookie == cookie)
 302         {
 303             list_remove(&sink->entry);
 304             heap_free(sink);
 305             LeaveCriticalSection(&clock->cs);
 306             return S_OK;
 307         }
 308     }
 309
 310     LeaveCriticalSection(&clock->cs);
 311
 312     return S_FALSE;
 313 }
 314
 315 static const IReferenceClockVtbl SystemClock_vtbl =
 316 {
 317     SystemClockImpl_QueryInterface,
 318     SystemClockImpl_AddRef,
 319     SystemClockImpl_Release,
 320     SystemClockImpl_GetTime,
 321     SystemClockImpl_AdviseTime,
 322     SystemClockImpl_AdvisePeriodic,
 323     SystemClockImpl_Unadvise
 324 };
 325
 326 HRESULT system_clock_create(IUnknown *outer, IUnknown **out)
 327 {
 328     struct system_clock *object;
 329
 330     TRACE("outer %p, out %p.\n", outer, out);
 331
 332     if (!(object = heap_alloc_zero(sizeof(*object))))
 333     {
 334         *out = NULL;
 335         return E_OUTOFMEMORY;
 336     }
 337
 338     object->IReferenceClock_iface.lpVtbl = &SystemClock_vtbl;
 339     object->IUnknown_inner.lpVtbl = &system_clock_inner_vtbl;
 340     object->outer_unk = outer ? outer : &object->IUnknown_inner;
 341     object->refcount = 1;
 342     list_init(&object->sinks);
 343     InitializeCriticalSection(&object->cs);
 344     object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SystemClockImpl.cs");
 345
 346     TRACE("Created system clock %p.\n", object);
 347     *out = &object->IUnknown_inner;
 348
 349     return S_OK;
 350 }