dlls/strmbase/renderer.c

   1 /*
   2  * Generic Implementation of strmbase Base Renderer classes
   3  *
   4  * Copyright 2012 Aric Stewart, CodeWeavers
   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 "strmbase_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
  24
  25 static inline struct strmbase_renderer *impl_from_strmbase_filter(struct strmbase_filter *iface)
  26 {
  27     return CONTAINING_RECORD(iface, struct strmbase_renderer, filter);
  28 }
  29
  30 static inline struct strmbase_renderer *impl_from_IPin(IPin *iface)
  31 {
  32     return CONTAINING_RECORD(iface, struct strmbase_renderer, sink.pin.IPin_iface);
  33 }
  34
  35 static struct strmbase_pin *renderer_get_pin(struct strmbase_filter *iface, unsigned int index)
  36 {
  37     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
  38
  39     if (index == 0)
  40         return &filter->sink.pin;
  41     return NULL;
  42 }
  43
  44 static void renderer_destroy(struct strmbase_filter *iface)
  45 {
  46     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
  47     filter->pFuncsTable->renderer_destroy(filter);
  48 }
  49
  50 static HRESULT renderer_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
  51 {
  52     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
  53     HRESULT hr;
  54
  55     if (filter->pFuncsTable->renderer_query_interface
  56             && SUCCEEDED(hr = filter->pFuncsTable->renderer_query_interface(filter, iid, out)))
  57     {
  58         return hr;
  59     }
  60
  61     if (IsEqualGUID(iid, &IID_IMediaPosition))
  62         *out = &filter->passthrough.IMediaPosition_iface;
  63     else if (IsEqualGUID(iid, &IID_IMediaSeeking))
  64         *out = &filter->passthrough.IMediaSeeking_iface;
  65     else if (IsEqualGUID(iid, &IID_IQualityControl))
  66         *out = &filter->qc.IQualityControl_iface;
  67     else
  68         return E_NOINTERFACE;
  69
  70     IUnknown_AddRef((IUnknown *)*out);
  71     return S_OK;
  72 }
  73
  74 static HRESULT renderer_init_stream(struct strmbase_filter *iface)
  75 {
  76     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
  77
  78     if (filter->sink.pin.peer)
  79         ResetEvent(filter->state_event);
  80     filter->eos = FALSE;
  81     ResetEvent(filter->flush_event);
  82     if (filter->pFuncsTable->renderer_init_stream)
  83         filter->pFuncsTable->renderer_init_stream(filter);
  84
  85     return filter->sink.pin.peer ? S_FALSE : S_OK;
  86 }
  87
  88 static HRESULT renderer_start_stream(struct strmbase_filter *iface, REFERENCE_TIME start)
  89 {
  90     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
  91
  92     filter->stream_start = start;
  93     SetEvent(filter->state_event);
  94     if (filter->sink.pin.peer)
  95         filter->eos = FALSE;
  96     QualityControlRender_Start(&filter->qc, filter->stream_start);
  97     if (filter->sink.pin.peer && filter->pFuncsTable->renderer_start_stream)
  98         filter->pFuncsTable->renderer_start_stream(filter);
  99
 100     return S_OK;
 101 }
 102
 103 static HRESULT renderer_stop_stream(struct strmbase_filter *iface)
 104 {
 105     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 106
 107     if (filter->sink.pin.peer && filter->pFuncsTable->renderer_stop_stream)
 108         filter->pFuncsTable->renderer_stop_stream(filter);
 109
 110     return S_OK;
 111 }
 112
 113 static HRESULT renderer_cleanup_stream(struct strmbase_filter *iface)
 114 {
 115     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 116
 117     strmbase_passthrough_invalidate_time(&filter->passthrough);
 118     SetEvent(filter->state_event);
 119     SetEvent(filter->flush_event);
 120
 121     return S_OK;
 122 }
 123
 124 static HRESULT renderer_wait_state(struct strmbase_filter *iface, DWORD timeout)
 125 {
 126     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 127
 128     if (WaitForSingleObject(filter->state_event, timeout) == WAIT_TIMEOUT)
 129         return VFW_S_STATE_INTERMEDIATE;
 130     return S_OK;
 131 }
 132
 133 static const struct strmbase_filter_ops filter_ops =
 134 {
 135     .filter_get_pin = renderer_get_pin,
 136     .filter_destroy = renderer_destroy,
 137     .filter_query_interface = renderer_query_interface,
 138     .filter_init_stream = renderer_init_stream,
 139     .filter_start_stream = renderer_start_stream,
 140     .filter_stop_stream = renderer_stop_stream,
 141     .filter_cleanup_stream = renderer_cleanup_stream,
 142     .filter_wait_state = renderer_wait_state,
 143 };
 144
 145 static HRESULT sink_query_accept(struct strmbase_pin *pin, const AM_MEDIA_TYPE *mt)
 146 {
 147     struct strmbase_renderer *filter = impl_from_IPin(&pin->IPin_iface);
 148     return filter->pFuncsTable->pfnCheckMediaType(filter, mt);
 149 }
 150
 151 static HRESULT sink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
 152 {
 153     struct strmbase_renderer *filter = impl_from_IPin(&iface->IPin_iface);
 154     HRESULT hr;
 155
 156     if (filter->pFuncsTable->renderer_pin_query_interface
 157             && SUCCEEDED(hr = filter->pFuncsTable->renderer_pin_query_interface(filter, iid, out)))
 158         return hr;
 159
 160     if (IsEqualGUID(iid, &IID_IMemInputPin))
 161         *out = &filter->sink.IMemInputPin_iface;
 162     else
 163         return E_NOINTERFACE;
 164
 165     IUnknown_AddRef((IUnknown *)*out);
 166     return S_OK;
 167 }
 168
 169 static HRESULT WINAPI BaseRenderer_Receive(struct strmbase_sink *pin, IMediaSample *sample)
 170 {
 171     struct strmbase_renderer *filter = impl_from_IPin(&pin->pin.IPin_iface);
 172     REFERENCE_TIME start, stop;
 173     BOOL need_wait = FALSE;
 174     FILTER_STATE state;
 175     HRESULT hr = S_OK;
 176     AM_MEDIA_TYPE *mt;
 177
 178     if (filter->eos || filter->sink.flushing)
 179         return S_FALSE;
 180
 181     state = filter->filter.state;
 182     if (state == State_Stopped)
 183         return VFW_E_WRONG_STATE;
 184
 185     if (IMediaSample_GetMediaType(sample, &mt) == S_OK)
 186     {
 187         TRACE("Format change.\n");
 188         strmbase_dump_media_type(mt);
 189
 190         if (FAILED(filter->pFuncsTable->pfnCheckMediaType(filter, mt)))
 191             return VFW_E_TYPE_NOT_ACCEPTED;
 192         DeleteMediaType(mt);
 193     }
 194
 195     EnterCriticalSection(&filter->csRenderLock);
 196
 197     if (filter->filter.clock && SUCCEEDED(IMediaSample_GetTime(sample, &start, &stop)))
 198     {
 199         strmbase_passthrough_update_time(&filter->passthrough, start);
 200         need_wait = TRUE;
 201     }
 202     else
 203         start = stop = -1;
 204
 205     if (state == State_Paused)
 206     {
 207         QualityControlRender_BeginRender(&filter->qc, start, stop);
 208         hr = filter->pFuncsTable->pfnDoRenderSample(filter, sample);
 209         QualityControlRender_EndRender(&filter->qc);
 210     }
 211
 212     if (need_wait)
 213     {
 214         REFERENCE_TIME now;
 215         DWORD_PTR cookie;
 216
 217         IReferenceClock_GetTime(filter->filter.clock, &now);
 218
 219         if (now - filter->stream_start - start <= -10000)
 220         {
 221             HANDLE handles[2] = {filter->advise_event, filter->flush_event};
 222             DWORD ret;
 223
 224             IReferenceClock_AdviseTime(filter->filter.clock, filter->stream_start,
 225                     start, (HEVENT)filter->advise_event, &cookie);
 226
 227             ret = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 228             IReferenceClock_Unadvise(filter->filter.clock, cookie);
 229
 230             if (ret == 1)
 231             {
 232                 LeaveCriticalSection(&filter->csRenderLock);
 233                 TRACE("Flush signaled; discarding current sample.\n");
 234                 return S_OK;
 235             }
 236         }
 237     }
 238
 239     if (state == State_Running)
 240     {
 241         QualityControlRender_BeginRender(&filter->qc, start, stop);
 242         hr = filter->pFuncsTable->pfnDoRenderSample(filter, sample);
 243         QualityControlRender_EndRender(&filter->qc);
 244     }
 245
 246     QualityControlRender_DoQOS(&filter->qc);
 247
 248     LeaveCriticalSection(&filter->csRenderLock);
 249
 250     return hr;
 251 }
 252
 253 static HRESULT sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 254 {
 255     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 256
 257     if (filter->pFuncsTable->renderer_connect)
 258         return filter->pFuncsTable->renderer_connect(filter, mt);
 259     return S_OK;
 260 }
 261
 262 static void sink_disconnect(struct strmbase_sink *iface)
 263 {
 264     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 265
 266     if (filter->pFuncsTable->pfnBreakConnect)
 267         filter->pFuncsTable->pfnBreakConnect(filter);
 268 }
 269
 270 static HRESULT sink_eos(struct strmbase_sink *iface)
 271 {
 272     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 273     IFilterGraph *graph = filter->filter.graph;
 274     IMediaEventSink *event_sink;
 275
 276     EnterCriticalSection(&filter->csRenderLock);
 277
 278     filter->eos = TRUE;
 279
 280     if (graph && SUCCEEDED(IFilterGraph_QueryInterface(graph,
 281             &IID_IMediaEventSink, (void **)&event_sink)))
 282     {
 283         IMediaEventSink_Notify(event_sink, EC_COMPLETE, S_OK,
 284                 (LONG_PTR)&filter->filter.IBaseFilter_iface);
 285         IMediaEventSink_Release(event_sink);
 286     }
 287     strmbase_passthrough_eos(&filter->passthrough);
 288     SetEvent(filter->state_event);
 289
 290     LeaveCriticalSection(&filter->csRenderLock);
 291     return S_OK;
 292 }
 293
 294 static HRESULT sink_begin_flush(struct strmbase_sink *iface)
 295 {
 296     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 297
 298     SetEvent(filter->flush_event);
 299
 300     return S_OK;
 301 }
 302
 303 static HRESULT sink_end_flush(struct strmbase_sink *iface)
 304 {
 305     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 306
 307     EnterCriticalSection(&filter->csRenderLock);
 308
 309     filter->eos = FALSE;
 310     QualityControlRender_Start(&filter->qc, filter->stream_start);
 311     strmbase_passthrough_invalidate_time(&filter->passthrough);
 312     ResetEvent(filter->flush_event);
 313
 314     LeaveCriticalSection(&filter->csRenderLock);
 315     return S_OK;
 316 }
 317
 318 static const struct strmbase_sink_ops sink_ops =
 319 {
 320     .base.pin_query_accept = sink_query_accept,
 321     .base.pin_query_interface = sink_query_interface,
 322     .pfnReceive = BaseRenderer_Receive,
 323     .sink_connect = sink_connect,
 324     .sink_disconnect = sink_disconnect,
 325     .sink_eos = sink_eos,
 326     .sink_begin_flush = sink_begin_flush,
 327     .sink_end_flush = sink_end_flush,
 328 };
 329
 330 void strmbase_renderer_cleanup(struct strmbase_renderer *filter)
 331 {
 332     if (filter->sink.pin.peer)
 333         IPin_Disconnect(filter->sink.pin.peer);
 334     IPin_Disconnect(&filter->sink.pin.IPin_iface);
 335     strmbase_sink_cleanup(&filter->sink);
 336
 337     strmbase_passthrough_cleanup(&filter->passthrough);
 338
 339     filter->csRenderLock.DebugInfo->Spare[0] = 0;
 340     DeleteCriticalSection(&filter->csRenderLock);
 341
 342     CloseHandle(filter->state_event);
 343     CloseHandle(filter->advise_event);
 344     CloseHandle(filter->flush_event);
 345     strmbase_filter_cleanup(&filter->filter);
 346 }
 347
 348 void strmbase_renderer_init(struct strmbase_renderer *filter, IUnknown *outer,
 349         const CLSID *clsid, const WCHAR *sink_name, const struct strmbase_renderer_ops *ops)
 350 {
 351     memset(filter, 0, sizeof(*filter));
 352     strmbase_filter_init(&filter->filter, outer, clsid, &filter_ops);
 353     strmbase_passthrough_init(&filter->passthrough, (IUnknown *)&filter->filter.IBaseFilter_iface);
 354     ISeekingPassThru_Init(&filter->passthrough.ISeekingPassThru_iface, TRUE, &filter->sink.pin.IPin_iface);
 355     strmbase_qc_init(&filter->qc, &filter->sink.pin);
 356
 357     filter->pFuncsTable = ops;
 358
 359     strmbase_sink_init(&filter->sink, &filter->filter, sink_name, &sink_ops, NULL);
 360
 361     InitializeCriticalSection(&filter->csRenderLock);
 362     filter->csRenderLock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__": strmbase_renderer.csRenderLock");
 363     filter->state_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 364     filter->advise_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 365     filter->flush_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 366 }