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             LeaveCriticalSection(&filter->csRenderLock);
 228
 229             ret = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 230             IReferenceClock_Unadvise(filter->filter.clock, cookie);
 231
 232             if (ret == 1)
 233             {
 234                 TRACE("Flush signaled; discarding current sample.\n");
 235                 return S_OK;
 236             }
 237
 238             EnterCriticalSection(&filter->csRenderLock);
 239         }
 240     }
 241
 242     if (state == State_Running)
 243     {
 244         QualityControlRender_BeginRender(&filter->qc, start, stop);
 245         hr = filter->pFuncsTable->pfnDoRenderSample(filter, sample);
 246         QualityControlRender_EndRender(&filter->qc);
 247     }
 248
 249     QualityControlRender_DoQOS(&filter->qc);
 250
 251     LeaveCriticalSection(&filter->csRenderLock);
 252
 253     return hr;
 254 }
 255
 256 static HRESULT sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 257 {
 258     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 259
 260     if (filter->pFuncsTable->renderer_connect)
 261         return filter->pFuncsTable->renderer_connect(filter, mt);
 262     return S_OK;
 263 }
 264
 265 static void sink_disconnect(struct strmbase_sink *iface)
 266 {
 267     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 268
 269     if (filter->pFuncsTable->pfnBreakConnect)
 270         filter->pFuncsTable->pfnBreakConnect(filter);
 271 }
 272
 273 static HRESULT sink_eos(struct strmbase_sink *iface)
 274 {
 275     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 276     IFilterGraph *graph = filter->filter.graph;
 277     IMediaEventSink *event_sink;
 278
 279     EnterCriticalSection(&filter->csRenderLock);
 280
 281     filter->eos = TRUE;
 282
 283     if (graph && SUCCEEDED(IFilterGraph_QueryInterface(graph,
 284             &IID_IMediaEventSink, (void **)&event_sink)))
 285     {
 286         IMediaEventSink_Notify(event_sink, EC_COMPLETE, S_OK,
 287                 (LONG_PTR)&filter->filter.IBaseFilter_iface);
 288         IMediaEventSink_Release(event_sink);
 289     }
 290     strmbase_passthrough_eos(&filter->passthrough);
 291     SetEvent(filter->state_event);
 292
 293     LeaveCriticalSection(&filter->csRenderLock);
 294     return S_OK;
 295 }
 296
 297 static HRESULT sink_begin_flush(struct strmbase_sink *iface)
 298 {
 299     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 300
 301     SetEvent(filter->flush_event);
 302
 303     return S_OK;
 304 }
 305
 306 static HRESULT sink_end_flush(struct strmbase_sink *iface)
 307 {
 308     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 309
 310     EnterCriticalSection(&filter->csRenderLock);
 311
 312     filter->eos = FALSE;
 313     QualityControlRender_Start(&filter->qc, filter->stream_start);
 314     strmbase_passthrough_invalidate_time(&filter->passthrough);
 315     ResetEvent(filter->flush_event);
 316
 317     LeaveCriticalSection(&filter->csRenderLock);
 318     return S_OK;
 319 }
 320
 321 static const struct strmbase_sink_ops sink_ops =
 322 {
 323     .base.pin_query_accept = sink_query_accept,
 324     .base.pin_query_interface = sink_query_interface,
 325     .pfnReceive = BaseRenderer_Receive,
 326     .sink_connect = sink_connect,
 327     .sink_disconnect = sink_disconnect,
 328     .sink_eos = sink_eos,
 329     .sink_begin_flush = sink_begin_flush,
 330     .sink_end_flush = sink_end_flush,
 331 };
 332
 333 void strmbase_renderer_cleanup(struct strmbase_renderer *filter)
 334 {
 335     if (filter->sink.pin.peer)
 336         IPin_Disconnect(filter->sink.pin.peer);
 337     IPin_Disconnect(&filter->sink.pin.IPin_iface);
 338     strmbase_sink_cleanup(&filter->sink);
 339
 340     strmbase_passthrough_cleanup(&filter->passthrough);
 341
 342     filter->csRenderLock.DebugInfo->Spare[0] = 0;
 343     DeleteCriticalSection(&filter->csRenderLock);
 344
 345     CloseHandle(filter->state_event);
 346     CloseHandle(filter->advise_event);
 347     CloseHandle(filter->flush_event);
 348     strmbase_filter_cleanup(&filter->filter);
 349 }
 350
 351 void strmbase_renderer_init(struct strmbase_renderer *filter, IUnknown *outer,
 352         const CLSID *clsid, const WCHAR *sink_name, const struct strmbase_renderer_ops *ops)
 353 {
 354     memset(filter, 0, sizeof(*filter));
 355     strmbase_filter_init(&filter->filter, outer, clsid, &filter_ops);
 356     strmbase_passthrough_init(&filter->passthrough, (IUnknown *)&filter->filter.IBaseFilter_iface);
 357     ISeekingPassThru_Init(&filter->passthrough.ISeekingPassThru_iface, TRUE, &filter->sink.pin.IPin_iface);
 358     strmbase_qc_init(&filter->qc, &filter->sink.pin);
 359
 360     filter->pFuncsTable = ops;
 361
 362     strmbase_sink_init(&filter->sink, &filter->filter, sink_name, &sink_ops, NULL);
 363
 364     InitializeCriticalSection(&filter->csRenderLock);
 365     filter->csRenderLock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__": strmbase_renderer.csRenderLock");
 366     filter->state_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 367     filter->advise_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 368     filter->flush_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 369 }