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 /* The following quality-of-service code is based on GstBaseSink QoS code, which
  26  * is covered by the following copyright information:
  27  *
  28  * GStreamer
  29  * Copyright (C) 2005-2007 Wim Taymans <wim.taymans@gmail.com>
  30  *
  31  * gstbasesink.c: Base class for sink elements
  32  *
  33  * This library is free software; you can redistribute it and/or
  34  * modify it under the terms of the GNU Library General Public
  35  * License as published by the Free Software Foundation; either
  36  * version 2 of the License, or (at your option) any later version.
  37  *
  38  * This library is distributed in the hope that it will be useful,
  39  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  40  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  41  * Library General Public License for more details.
  42  *
  43  * You should have received a copy of the GNU Library General Public
  44  * License along with this library; if not, write to the
  45  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  46  * Boston, MA 02110-1301, USA.
  47  */
  48
  49 #define DO_RUNNING_AVG(avg,val,size) (((val) + ((size)-1) * (avg)) / (size))
  50
  51 /* Generic running average; this has a neutral window size. */
  52 #define UPDATE_RUNNING_AVG(avg,val)   DO_RUNNING_AVG(avg,val,8)
  53
  54 /* The windows for these running averages are experimentally obtained.
  55  * Positive values get averaged more, while negative values use a small
  56  * window so we can react faster to badness. */
  57 #define UPDATE_RUNNING_AVG_P(avg,val) DO_RUNNING_AVG(avg,val,16)
  58 #define UPDATE_RUNNING_AVG_N(avg,val) DO_RUNNING_AVG(avg,val,4)
  59
  60 static void reset_qos(struct strmbase_renderer *filter)
  61 {
  62     filter->last_left = filter->avg_duration = filter->avg_pt = -1;
  63     filter->avg_rate = -1.0;
  64 }
  65
  66 static void perform_qos(struct strmbase_renderer *filter,
  67         const REFERENCE_TIME start, const REFERENCE_TIME stop, REFERENCE_TIME jitter)
  68 {
  69     REFERENCE_TIME pt, entered, left, duration;
  70     double rate;
  71
  72     if (jitter < 0)
  73     {
  74         /* This is the time the buffer entered the sink. */
  75         if (start < -jitter)
  76             entered = 0;
  77         else
  78             entered = start + jitter;
  79         left = start;
  80     }
  81     else
  82     {
  83         /* This is the time the buffer entered the sink. */
  84         entered = start + jitter;
  85         /* This is the time the buffer left the sink. */
  86         left = start + jitter;
  87     }
  88
  89     /* Calculate the duration of the buffer. */
  90     if (stop >= start)
  91         duration = stop - start;
  92     else
  93         duration = 0;
  94
  95     /* If we have the time when the last buffer left us, calculate processing
  96      * time. */
  97     if (filter->last_left >= 0)
  98     {
  99         if (entered > filter->last_left)
 100             pt = entered - filter->last_left;
 101         else
 102             pt = 0;
 103     }
 104     else
 105     {
 106         pt = filter->avg_pt;
 107     }
 108
 109     TRACE("start %s, entered %s, left %s, pt %s, duration %s, jitter %s.\n",
 110             debugstr_time(start), debugstr_time(entered), debugstr_time(left),
 111             debugstr_time(pt), debugstr_time(duration), debugstr_time(jitter));
 112
 113     TRACE("average duration %s, average pt %s, average rate %.16e.\n",
 114             debugstr_time(filter->avg_duration), debugstr_time(filter->avg_pt), filter->avg_rate);
 115
 116     /* Collect running averages. For first observations, we copy the values. */
 117     if (filter->avg_duration < 0)
 118         filter->avg_duration = duration;
 119     else
 120         filter->avg_duration = UPDATE_RUNNING_AVG(filter->avg_duration, duration);
 121
 122     if (filter->avg_pt < 0)
 123         filter->avg_pt = pt;
 124     else
 125         filter->avg_pt = UPDATE_RUNNING_AVG(filter->avg_pt, pt);
 126
 127     if (filter->avg_duration != 0)
 128         rate = (double)filter->avg_pt / (double)filter->avg_duration;
 129     else
 130         rate = 0.0;
 131
 132     if (filter->last_left >= 0)
 133     {
 134         if (filter->avg_rate < 0.0)
 135         {
 136             filter->avg_rate = rate;
 137         }
 138         else
 139         {
 140             if (rate > 1.0)
 141                 filter->avg_rate = UPDATE_RUNNING_AVG_N(filter->avg_rate, rate);
 142             else
 143                 filter->avg_rate = UPDATE_RUNNING_AVG_P(filter->avg_rate, rate);
 144         }
 145     }
 146
 147     if (filter->avg_rate >= 0.0)
 148     {
 149         Quality q;
 150
 151         /* If we have a valid rate, start sending QoS messages. */
 152         if (jitter < 0)
 153         {
 154             /* Make sure we never go below 0 when adding the jitter to the
 155              * timestamp. */
 156             if (start < -jitter)
 157                 jitter = -start;
 158         }
 159         else
 160         {
 161             jitter += stop - start;
 162         }
 163
 164         q.Type = (jitter > 0 ? Famine : Flood);
 165         q.Proportion = 1000.0 / filter->avg_rate;
 166         if (q.Proportion < 200)
 167             q.Proportion = 200;
 168         else if (q.Proportion > 5000)
 169             q.Proportion = 5000;
 170         q.Late = jitter;
 171         q.TimeStamp = start;
 172         IQualityControl_Notify(&filter->IQualityControl_iface, &filter->filter.IBaseFilter_iface, q);
 173     }
 174
 175     /* Record when this buffer will leave us. */
 176     filter->last_left = left;
 177 }
 178
 179 static inline struct strmbase_renderer *impl_from_strmbase_filter(struct strmbase_filter *iface)
 180 {
 181     return CONTAINING_RECORD(iface, struct strmbase_renderer, filter);
 182 }
 183
 184 static inline struct strmbase_renderer *impl_from_IPin(IPin *iface)
 185 {
 186     return CONTAINING_RECORD(iface, struct strmbase_renderer, sink.pin.IPin_iface);
 187 }
 188
 189 static struct strmbase_pin *renderer_get_pin(struct strmbase_filter *iface, unsigned int index)
 190 {
 191     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 192
 193     if (index == 0)
 194         return &filter->sink.pin;
 195     return NULL;
 196 }
 197
 198 static void renderer_destroy(struct strmbase_filter *iface)
 199 {
 200     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 201     filter->ops->renderer_destroy(filter);
 202 }
 203
 204 static HRESULT renderer_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
 205 {
 206     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 207     HRESULT hr;
 208
 209     if (filter->ops->renderer_query_interface
 210             && SUCCEEDED(hr = filter->ops->renderer_query_interface(filter, iid, out)))
 211     {
 212         return hr;
 213     }
 214
 215     if (IsEqualGUID(iid, &IID_IMediaPosition))
 216         *out = &filter->passthrough.IMediaPosition_iface;
 217     else if (IsEqualGUID(iid, &IID_IMediaSeeking))
 218         *out = &filter->passthrough.IMediaSeeking_iface;
 219     else if (IsEqualGUID(iid, &IID_IQualityControl))
 220         *out = &filter->IQualityControl_iface;
 221     else
 222         return E_NOINTERFACE;
 223
 224     IUnknown_AddRef((IUnknown *)*out);
 225     return S_OK;
 226 }
 227
 228 static HRESULT renderer_init_stream(struct strmbase_filter *iface)
 229 {
 230     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 231
 232     if (filter->sink.pin.peer)
 233         ResetEvent(filter->state_event);
 234     filter->eos = FALSE;
 235     ResetEvent(filter->flush_event);
 236     if (filter->ops->renderer_init_stream)
 237         filter->ops->renderer_init_stream(filter);
 238
 239     return filter->sink.pin.peer ? S_FALSE : S_OK;
 240 }
 241
 242 static HRESULT renderer_start_stream(struct strmbase_filter *iface, REFERENCE_TIME start)
 243 {
 244     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 245
 246     filter->stream_start = start;
 247     SetEvent(filter->state_event);
 248     SetEvent(filter->run_event);
 249     if (filter->sink.pin.peer)
 250         filter->eos = FALSE;
 251     reset_qos(filter);
 252     if (filter->sink.pin.peer && filter->ops->renderer_start_stream)
 253         filter->ops->renderer_start_stream(filter);
 254
 255     return S_OK;
 256 }
 257
 258 static HRESULT renderer_stop_stream(struct strmbase_filter *iface)
 259 {
 260     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 261
 262     ResetEvent(filter->run_event);
 263
 264     if (filter->sink.pin.peer && filter->ops->renderer_stop_stream)
 265         filter->ops->renderer_stop_stream(filter);
 266
 267     return S_OK;
 268 }
 269
 270 static HRESULT renderer_cleanup_stream(struct strmbase_filter *iface)
 271 {
 272     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 273
 274     strmbase_passthrough_invalidate_time(&filter->passthrough);
 275     SetEvent(filter->state_event);
 276     SetEvent(filter->flush_event);
 277
 278     return S_OK;
 279 }
 280
 281 static HRESULT renderer_wait_state(struct strmbase_filter *iface, DWORD timeout)
 282 {
 283     struct strmbase_renderer *filter = impl_from_strmbase_filter(iface);
 284
 285     if (WaitForSingleObject(filter->state_event, timeout) == WAIT_TIMEOUT)
 286         return VFW_S_STATE_INTERMEDIATE;
 287     return S_OK;
 288 }
 289
 290 static const struct strmbase_filter_ops filter_ops =
 291 {
 292     .filter_get_pin = renderer_get_pin,
 293     .filter_destroy = renderer_destroy,
 294     .filter_query_interface = renderer_query_interface,
 295     .filter_init_stream = renderer_init_stream,
 296     .filter_start_stream = renderer_start_stream,
 297     .filter_stop_stream = renderer_stop_stream,
 298     .filter_cleanup_stream = renderer_cleanup_stream,
 299     .filter_wait_state = renderer_wait_state,
 300 };
 301
 302 static HRESULT sink_query_accept(struct strmbase_pin *pin, const AM_MEDIA_TYPE *mt)
 303 {
 304     struct strmbase_renderer *filter = impl_from_IPin(&pin->IPin_iface);
 305     return filter->ops->renderer_query_accept(filter, mt);
 306 }
 307
 308 static HRESULT sink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
 309 {
 310     struct strmbase_renderer *filter = impl_from_IPin(&iface->IPin_iface);
 311     HRESULT hr;
 312
 313     if (filter->ops->renderer_pin_query_interface
 314             && SUCCEEDED(hr = filter->ops->renderer_pin_query_interface(filter, iid, out)))
 315         return hr;
 316
 317     if (IsEqualGUID(iid, &IID_IMemInputPin))
 318         *out = &filter->sink.IMemInputPin_iface;
 319     else
 320         return E_NOINTERFACE;
 321
 322     IUnknown_AddRef((IUnknown *)*out);
 323     return S_OK;
 324 }
 325
 326 static HRESULT WINAPI BaseRenderer_Receive(struct strmbase_sink *pin, IMediaSample *sample)
 327 {
 328     struct strmbase_renderer *filter = impl_from_IPin(&pin->pin.IPin_iface);
 329     REFERENCE_TIME start, stop;
 330     BOOL need_wait = FALSE;
 331     FILTER_STATE state;
 332     HRESULT hr = S_OK;
 333     AM_MEDIA_TYPE *mt;
 334
 335     if (filter->eos || filter->sink.flushing)
 336         return S_FALSE;
 337
 338     state = filter->filter.state;
 339     if (state == State_Stopped)
 340         return VFW_E_WRONG_STATE;
 341
 342     if (IMediaSample_GetMediaType(sample, &mt) == S_OK)
 343     {
 344         TRACE("Format change.\n");
 345         strmbase_dump_media_type(mt);
 346
 347         if (FAILED(filter->ops->renderer_query_accept(filter, mt)))
 348             return VFW_E_TYPE_NOT_ACCEPTED;
 349         DeleteMediaType(mt);
 350     }
 351
 352     if (filter->filter.clock && SUCCEEDED(IMediaSample_GetTime(sample, &start, &stop)))
 353     {
 354         strmbase_passthrough_update_time(&filter->passthrough, start);
 355         need_wait = TRUE;
 356     }
 357
 358     if (state == State_Paused)
 359     {
 360         HANDLE events[2] = {filter->run_event, filter->flush_event};
 361
 362         filter->current_sample = sample;
 363
 364         hr = filter->ops->renderer_render(filter, sample);
 365
 366         SetEvent(filter->state_event);
 367         LeaveCriticalSection(&filter->filter.stream_cs);
 368         WaitForMultipleObjects(2, events, FALSE, INFINITE);
 369         EnterCriticalSection(&filter->filter.stream_cs);
 370
 371         filter->current_sample = NULL;
 372     }
 373
 374     if (need_wait)
 375     {
 376         REFERENCE_TIME now, jitter;
 377         DWORD_PTR cookie;
 378
 379         IReferenceClock_GetTime(filter->filter.clock, &now);
 380
 381         /* "jitter" describes how early (negative) or late (positive) this
 382          * buffer arrived, relative to its PTS. */
 383         jitter = (now - filter->stream_start) - start;
 384
 385         if (jitter <= -10000) /* if we are early by at least 1 ms */
 386         {
 387             HANDLE handles[2] = {filter->advise_event, filter->flush_event};
 388             DWORD ret;
 389
 390             IReferenceClock_AdviseTime(filter->filter.clock, filter->stream_start,
 391                     start, (HEVENT)filter->advise_event, &cookie);
 392
 393             ret = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 394             IReferenceClock_Unadvise(filter->filter.clock, cookie);
 395
 396             if (ret == 1)
 397             {
 398                 TRACE("Flush signaled; discarding current sample.\n");
 399                 return S_OK;
 400             }
 401         }
 402
 403         if (state == State_Running)
 404             hr = filter->ops->renderer_render(filter, sample);
 405
 406         perform_qos(filter, start, stop, jitter);
 407     }
 408     else
 409     {
 410         if (state == State_Running)
 411             hr = filter->ops->renderer_render(filter, sample);
 412     }
 413
 414     return hr;
 415 }
 416
 417 static HRESULT sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 418 {
 419     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 420
 421     if (filter->ops->renderer_connect)
 422         return filter->ops->renderer_connect(filter, mt);
 423     return S_OK;
 424 }
 425
 426 static void sink_disconnect(struct strmbase_sink *iface)
 427 {
 428     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 429
 430     if (filter->ops->renderer_disconnect)
 431         filter->ops->renderer_disconnect(filter);
 432 }
 433
 434 static HRESULT sink_eos(struct strmbase_sink *iface)
 435 {
 436     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 437     IFilterGraph *graph = filter->filter.graph;
 438     IMediaEventSink *event_sink;
 439
 440     filter->eos = TRUE;
 441
 442     if (graph && SUCCEEDED(IFilterGraph_QueryInterface(graph,
 443             &IID_IMediaEventSink, (void **)&event_sink)))
 444     {
 445         IMediaEventSink_Notify(event_sink, EC_COMPLETE, S_OK,
 446                 (LONG_PTR)&filter->filter.IBaseFilter_iface);
 447         IMediaEventSink_Release(event_sink);
 448     }
 449     strmbase_passthrough_eos(&filter->passthrough);
 450     SetEvent(filter->state_event);
 451
 452     return S_OK;
 453 }
 454
 455 static HRESULT sink_begin_flush(struct strmbase_sink *iface)
 456 {
 457     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 458
 459     SetEvent(filter->flush_event);
 460
 461     return S_OK;
 462 }
 463
 464 static HRESULT sink_end_flush(struct strmbase_sink *iface)
 465 {
 466     struct strmbase_renderer *filter = impl_from_IPin(&iface->pin.IPin_iface);
 467
 468     EnterCriticalSection(&filter->filter.stream_cs);
 469
 470     filter->eos = FALSE;
 471     reset_qos(filter);
 472     strmbase_passthrough_invalidate_time(&filter->passthrough);
 473     ResetEvent(filter->flush_event);
 474
 475     LeaveCriticalSection(&filter->filter.stream_cs);
 476     return S_OK;
 477 }
 478
 479 static const struct strmbase_sink_ops sink_ops =
 480 {
 481     .base.pin_query_accept = sink_query_accept,
 482     .base.pin_query_interface = sink_query_interface,
 483     .pfnReceive = BaseRenderer_Receive,
 484     .sink_connect = sink_connect,
 485     .sink_disconnect = sink_disconnect,
 486     .sink_eos = sink_eos,
 487     .sink_begin_flush = sink_begin_flush,
 488     .sink_end_flush = sink_end_flush,
 489 };
 490
 491 static struct strmbase_renderer *impl_from_IQualityControl(IQualityControl *iface)
 492 {
 493     return CONTAINING_RECORD(iface, struct strmbase_renderer, IQualityControl_iface);
 494 }
 495
 496 static HRESULT WINAPI quality_control_QueryInterface(IQualityControl *iface, REFIID iid, void **out)
 497 {
 498     struct strmbase_renderer *filter = impl_from_IQualityControl(iface);
 499     return IUnknown_QueryInterface(filter->filter.outer_unk, iid, out);
 500 }
 501
 502 static ULONG WINAPI quality_control_AddRef(IQualityControl *iface)
 503 {
 504     struct strmbase_renderer *filter = impl_from_IQualityControl(iface);
 505     return IUnknown_AddRef(filter->filter.outer_unk);
 506 }
 507
 508 static ULONG WINAPI quality_control_Release(IQualityControl *iface)
 509 {
 510     struct strmbase_renderer *filter = impl_from_IQualityControl(iface);
 511     return IUnknown_Release(filter->filter.outer_unk);
 512 }
 513
 514 static HRESULT WINAPI quality_control_Notify(IQualityControl *iface, IBaseFilter *sender, Quality q)
 515 {
 516     struct strmbase_renderer *filter = impl_from_IQualityControl(iface);
 517     HRESULT hr = S_FALSE;
 518
 519     TRACE("filter %p, sender %p, type %#x, proportion %u, late %s, timestamp %s.\n",
 520             filter, sender, q.Type, q.Proportion, debugstr_time(q.Late), debugstr_time(q.TimeStamp));
 521
 522     if (filter->qc_sink)
 523         return IQualityControl_Notify(filter->qc_sink, &filter->filter.IBaseFilter_iface, q);
 524
 525     if (filter->sink.pin.peer)
 526     {
 527         IQualityControl *peer_qc = NULL;
 528         IPin_QueryInterface(filter->sink.pin.peer, &IID_IQualityControl, (void **)&peer_qc);
 529         if (peer_qc)
 530         {
 531             hr = IQualityControl_Notify(peer_qc, &filter->filter.IBaseFilter_iface, q);
 532             IQualityControl_Release(peer_qc);
 533         }
 534     }
 535
 536     return hr;
 537 }
 538
 539 static HRESULT WINAPI quality_control_SetSink(IQualityControl *iface, IQualityControl *sink)
 540 {
 541     struct strmbase_renderer *filter = impl_from_IQualityControl(iface);
 542
 543     TRACE("filter %p, sink %p.\n", filter, sink);
 544
 545     filter->qc_sink = sink;
 546     return S_OK;
 547 }
 548
 549 static const IQualityControlVtbl quality_control_vtbl =
 550 {
 551     quality_control_QueryInterface,
 552     quality_control_AddRef,
 553     quality_control_Release,
 554     quality_control_Notify,
 555     quality_control_SetSink,
 556 };
 557
 558 void strmbase_renderer_cleanup(struct strmbase_renderer *filter)
 559 {
 560     if (filter->sink.pin.peer)
 561         IPin_Disconnect(filter->sink.pin.peer);
 562     IPin_Disconnect(&filter->sink.pin.IPin_iface);
 563     strmbase_sink_cleanup(&filter->sink);
 564
 565     strmbase_passthrough_cleanup(&filter->passthrough);
 566
 567     CloseHandle(filter->state_event);
 568     CloseHandle(filter->advise_event);
 569     CloseHandle(filter->run_event);
 570     CloseHandle(filter->flush_event);
 571     strmbase_filter_cleanup(&filter->filter);
 572 }
 573
 574 void strmbase_renderer_init(struct strmbase_renderer *filter, IUnknown *outer,
 575         const CLSID *clsid, const WCHAR *sink_name, const struct strmbase_renderer_ops *ops)
 576 {
 577     memset(filter, 0, sizeof(*filter));
 578     strmbase_filter_init(&filter->filter, outer, clsid, &filter_ops);
 579     strmbase_passthrough_init(&filter->passthrough, (IUnknown *)&filter->filter.IBaseFilter_iface);
 580     ISeekingPassThru_Init(&filter->passthrough.ISeekingPassThru_iface, TRUE, &filter->sink.pin.IPin_iface);
 581     filter->IQualityControl_iface.lpVtbl = &quality_control_vtbl;
 582
 583     filter->ops = ops;
 584
 585     strmbase_sink_init(&filter->sink, &filter->filter, sink_name, &sink_ops, NULL);
 586
 587     filter->state_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 588     filter->advise_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 589     filter->run_event = CreateEventW(NULL, TRUE, FALSE, NULL);
 590     filter->flush_event = CreateEventW(NULL, TRUE, TRUE, NULL);
 591 }