dlls/mf/quality.c

   1 /*
   2  * Copyright 2022 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "mf_private.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  29
  30 enum quality_manager_state
  31 {
  32     QUALITY_MANAGER_READY = 0,
  33     QUALITY_MANAGER_SHUT_DOWN,
  34 };
  35
  36 struct quality_manager
  37 {
  38     IMFQualityManager IMFQualityManager_iface;
  39     IMFClockStateSink IMFClockStateSink_iface;
  40     LONG refcount;
  41
  42     IMFTopology *topology;
  43     IMFPresentationClock *clock;
  44     unsigned int state;
  45     CRITICAL_SECTION cs;
  46 };
  47
  48 static struct quality_manager *impl_from_IMFQualityManager(IMFQualityManager *iface)
  49 {
  50     return CONTAINING_RECORD(iface, struct quality_manager, IMFQualityManager_iface);
  51 }
  52
  53 static struct quality_manager *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
  54 {
  55     return CONTAINING_RECORD(iface, struct quality_manager, IMFClockStateSink_iface);
  56 }
  57
  58 static HRESULT WINAPI standard_quality_manager_QueryInterface(IMFQualityManager *iface, REFIID riid, void **out)
  59 {
  60     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
  61
  62     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
  63
  64     if (IsEqualIID(riid, &IID_IMFQualityManager) ||
  65             IsEqualIID(riid, &IID_IUnknown))
  66     {
  67         *out = iface;
  68     }
  69     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
  70     {
  71         *out = &manager->IMFClockStateSink_iface;
  72     }
  73     else
  74     {
  75         WARN("Unsupported %s.\n", debugstr_guid(riid));
  76         *out = NULL;
  77         return E_NOINTERFACE;
  78     }
  79
  80     IUnknown_AddRef((IUnknown *)*out);
  81     return S_OK;
  82 }
  83
  84 static ULONG WINAPI standard_quality_manager_AddRef(IMFQualityManager *iface)
  85 {
  86     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
  87     ULONG refcount = InterlockedIncrement(&manager->refcount);
  88
  89     TRACE("%p, refcount %u.\n", iface, refcount);
  90
  91     return refcount;
  92 }
  93
  94 static ULONG WINAPI standard_quality_manager_Release(IMFQualityManager *iface)
  95 {
  96     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
  97     ULONG refcount = InterlockedDecrement(&manager->refcount);
  98
  99     TRACE("%p, refcount %u.\n", iface, refcount);
 100
 101     if (!refcount)
 102     {
 103         if (manager->clock)
 104             IMFPresentationClock_Release(manager->clock);
 105         if (manager->topology)
 106             IMFTopology_Release(manager->topology);
 107         DeleteCriticalSection(&manager->cs);
 108         free(manager);
 109     }
 110
 111     return refcount;
 112 }
 113
 114 static void standard_quality_manager_set_topology(struct quality_manager *manager, IMFTopology *topology)
 115 {
 116     if (manager->topology)
 117         IMFTopology_Release(manager->topology);
 118     manager->topology = topology;
 119     if (manager->topology)
 120         IMFTopology_AddRef(manager->topology);
 121 }
 122
 123 static HRESULT WINAPI standard_quality_manager_NotifyTopology(IMFQualityManager *iface, IMFTopology *topology)
 124 {
 125     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
 126     HRESULT hr = S_OK;
 127
 128     TRACE("%p, %p.\n", iface, topology);
 129
 130     EnterCriticalSection(&manager->cs);
 131     if (manager->state == QUALITY_MANAGER_SHUT_DOWN)
 132         hr = MF_E_SHUTDOWN;
 133     else
 134     {
 135         standard_quality_manager_set_topology(manager, topology);
 136     }
 137     LeaveCriticalSection(&manager->cs);
 138
 139     return hr;
 140 }
 141
 142 static void standard_quality_manager_release_clock(struct quality_manager *manager)
 143 {
 144     if (manager->clock)
 145     {
 146         IMFPresentationClock_RemoveClockStateSink(manager->clock, &manager->IMFClockStateSink_iface);
 147         IMFPresentationClock_Release(manager->clock);
 148     }
 149     manager->clock = NULL;
 150 }
 151
 152 static HRESULT WINAPI standard_quality_manager_NotifyPresentationClock(IMFQualityManager *iface,
 153         IMFPresentationClock *clock)
 154 {
 155     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
 156     HRESULT hr = S_OK;
 157
 158     TRACE("%p, %p.\n", iface, clock);
 159
 160     EnterCriticalSection(&manager->cs);
 161     if (manager->state == QUALITY_MANAGER_SHUT_DOWN)
 162         hr = MF_E_SHUTDOWN;
 163     else if (!clock)
 164         hr = E_POINTER;
 165     else
 166     {
 167         standard_quality_manager_release_clock(manager);
 168         manager->clock = clock;
 169         IMFPresentationClock_AddRef(manager->clock);
 170         if (FAILED(IMFPresentationClock_AddClockStateSink(manager->clock, &manager->IMFClockStateSink_iface)))
 171             WARN("Failed to set state sink.\n");
 172     }
 173     LeaveCriticalSection(&manager->cs);
 174
 175     return hr;
 176 }
 177
 178 static HRESULT WINAPI standard_quality_manager_NotifyProcessInput(IMFQualityManager *iface, IMFTopologyNode *node,
 179         LONG input_index, IMFSample *sample)
 180 {
 181     TRACE("%p, %p, %d, %p stub.\n", iface, node, input_index, sample);
 182
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI standard_quality_manager_NotifyProcessOutput(IMFQualityManager *iface, IMFTopologyNode *node,
 187         LONG output_index, IMFSample *sample)
 188 {
 189     TRACE("%p, %p, %d, %p stub.\n", iface, node, output_index, sample);
 190
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI standard_quality_manager_NotifyQualityEvent(IMFQualityManager *iface, IUnknown *object,
 195         IMFMediaEvent *event)
 196 {
 197     FIXME("%p, %p, %p stub.\n", iface, object, event);
 198
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI standard_quality_manager_Shutdown(IMFQualityManager *iface)
 203 {
 204     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
 205
 206     TRACE("%p.\n", iface);
 207
 208     EnterCriticalSection(&manager->cs);
 209     if (manager->state != QUALITY_MANAGER_SHUT_DOWN)
 210     {
 211         standard_quality_manager_release_clock(manager);
 212         standard_quality_manager_set_topology(manager, NULL);
 213         manager->state = QUALITY_MANAGER_SHUT_DOWN;
 214     }
 215     LeaveCriticalSection(&manager->cs);
 216
 217     return S_OK;
 218 }
 219
 220 static const IMFQualityManagerVtbl standard_quality_manager_vtbl =
 221 {
 222     standard_quality_manager_QueryInterface,
 223     standard_quality_manager_AddRef,
 224     standard_quality_manager_Release,
 225     standard_quality_manager_NotifyTopology,
 226     standard_quality_manager_NotifyPresentationClock,
 227     standard_quality_manager_NotifyProcessInput,
 228     standard_quality_manager_NotifyProcessOutput,
 229     standard_quality_manager_NotifyQualityEvent,
 230     standard_quality_manager_Shutdown,
 231 };
 232
 233 static HRESULT WINAPI standard_quality_manager_sink_QueryInterface(IMFClockStateSink *iface,
 234         REFIID riid, void **obj)
 235 {
 236     struct quality_manager *manager = impl_from_IMFClockStateSink(iface);
 237     return IMFQualityManager_QueryInterface(&manager->IMFQualityManager_iface, riid, obj);
 238 }
 239
 240 static ULONG WINAPI standard_quality_manager_sink_AddRef(IMFClockStateSink *iface)
 241 {
 242     struct quality_manager *manager = impl_from_IMFClockStateSink(iface);
 243     return IMFQualityManager_AddRef(&manager->IMFQualityManager_iface);
 244 }
 245
 246 static ULONG WINAPI standard_quality_manager_sink_Release(IMFClockStateSink *iface)
 247 {
 248     struct quality_manager *manager = impl_from_IMFClockStateSink(iface);
 249     return IMFQualityManager_Release(&manager->IMFQualityManager_iface);
 250 }
 251
 252 static HRESULT WINAPI standard_quality_manager_sink_OnClockStart(IMFClockStateSink *iface,
 253         MFTIME systime, LONGLONG offset)
 254 {
 255     return S_OK;
 256 }
 257
 258 static HRESULT WINAPI standard_quality_manager_sink_OnClockStop(IMFClockStateSink *iface,
 259         MFTIME systime)
 260 {
 261     return S_OK;
 262 }
 263
 264 static HRESULT WINAPI standard_quality_manager_sink_OnClockPause(IMFClockStateSink *iface,
 265         MFTIME systime)
 266 {
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI standard_quality_manager_sink_OnClockRestart(IMFClockStateSink *iface,
 271         MFTIME systime)
 272 {
 273     return S_OK;
 274 }
 275
 276 static HRESULT WINAPI standard_quality_manager_sink_OnClockSetRate(IMFClockStateSink *iface,
 277         MFTIME systime, float rate)
 278 {
 279     return S_OK;
 280 }
 281
 282 static const IMFClockStateSinkVtbl standard_quality_manager_sink_vtbl =
 283 {
 284     standard_quality_manager_sink_QueryInterface,
 285     standard_quality_manager_sink_AddRef,
 286     standard_quality_manager_sink_Release,
 287     standard_quality_manager_sink_OnClockStart,
 288     standard_quality_manager_sink_OnClockStop,
 289     standard_quality_manager_sink_OnClockPause,
 290     standard_quality_manager_sink_OnClockRestart,
 291     standard_quality_manager_sink_OnClockSetRate,
 292 };
 293
 294 HRESULT WINAPI MFCreateStandardQualityManager(IMFQualityManager **manager)
 295 {
 296     struct quality_manager *object;
 297
 298     TRACE("%p.\n", manager);
 299
 300     if (!(object = calloc(1, sizeof(*object))))
 301         return E_OUTOFMEMORY;
 302
 303     object->IMFQualityManager_iface.lpVtbl = &standard_quality_manager_vtbl;
 304     object->IMFClockStateSink_iface.lpVtbl = &standard_quality_manager_sink_vtbl;
 305     object->refcount = 1;
 306     InitializeCriticalSection(&object->cs);
 307
 308     *manager = &object->IMFQualityManager_iface;
 309
 310     return S_OK;
 311 }