2 * Quality Control Interfaces
4 * Copyright 2010 Maarten Lankhorst for CodeWeavers
6 * rendering qos functions based on, the original can be found at
7 * gstreamer/libs/gst/base/gstbasesink.c which has copyright notice:
9 * Copyright (C) 2005-2007 Wim Taymans <wim.taymans@gmail.com>
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "strmbase_private.h"
28 #define XTIME_FMT "%u.%03u"
29 #define XTIME(u) (int)(u/10000000), (int)((u / 10000)%1000)
31 HRESULT
QualityControlImpl_Create(IPin
*input
, IBaseFilter
*self
, QualityControlImpl
**ppv
)
33 QualityControlImpl
*This
;
34 TRACE("%p, %p, %p\n", input
, self
, ppv
);
35 *ppv
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(QualityControlImpl
));
41 This
->tonotify
= NULL
;
43 This
->current_rstart
= This
->current_rstop
= -1;
44 TRACE("-> %p\n", This
);
48 void QualityControlImpl_Destroy(QualityControlImpl
*This
)
50 HeapFree(GetProcessHeap(),0,This
);
53 static inline QualityControlImpl
*impl_from_IQualityControl(IQualityControl
*iface
)
55 return CONTAINING_RECORD(iface
, QualityControlImpl
, IQualityControl_iface
);
58 HRESULT WINAPI
QualityControlImpl_QueryInterface(IQualityControl
*iface
, REFIID riid
, void **ppv
)
60 QualityControlImpl
*This
= impl_from_IQualityControl(iface
);
61 return IBaseFilter_QueryInterface(This
->self
, riid
, ppv
);
64 ULONG WINAPI
QualityControlImpl_AddRef(IQualityControl
*iface
)
66 QualityControlImpl
*This
= impl_from_IQualityControl(iface
);
67 return IBaseFilter_AddRef(This
->self
);
70 ULONG WINAPI
QualityControlImpl_Release(IQualityControl
*iface
)
72 QualityControlImpl
*This
= impl_from_IQualityControl(iface
);
73 return IBaseFilter_Release(This
->self
);
76 HRESULT WINAPI
QualityControlImpl_Notify(IQualityControl
*iface
, IBaseFilter
*sender
, Quality qm
)
78 QualityControlImpl
*This
= impl_from_IQualityControl(iface
);
81 TRACE("%p %p { 0x%x %u " XTIME_FMT
" " XTIME_FMT
" }\n",
82 This
, sender
, qm
.Type
, qm
.Proportion
,
83 XTIME(qm
.Late
), XTIME(qm
.TimeStamp
));
86 return IQualityControl_Notify(This
->tonotify
, This
->self
, qm
);
90 IPin_ConnectedTo(This
->input
, &to
);
92 IQualityControl
*qc
= NULL
;
93 IPin_QueryInterface(to
, &IID_IQualityControl
, (void**)&qc
);
95 hr
= IQualityControl_Notify(qc
, This
->self
, qm
);
96 IQualityControl_Release(qc
);
105 HRESULT WINAPI
QualityControlImpl_SetSink(IQualityControl
*iface
, IQualityControl
*tonotify
)
107 QualityControlImpl
*This
= impl_from_IQualityControl(iface
);
108 TRACE("%p %p\n", This
, tonotify
);
109 This
->tonotify
= tonotify
;
113 /* Macros copied from gstreamer, weighted average between old average and new ones */
114 #define DO_RUNNING_AVG(avg,val,size) (((val) + ((size)-1) * (avg)) / (size))
116 /* generic running average, this has a neutral window size */
117 #define UPDATE_RUNNING_AVG(avg,val) DO_RUNNING_AVG(avg,val,8)
119 /* the windows for these running averages are experimentally obtained.
120 * possitive values get averaged more while negative values use a small
121 * window so we can react faster to badness. */
122 #define UPDATE_RUNNING_AVG_P(avg,val) DO_RUNNING_AVG(avg,val,16)
123 #define UPDATE_RUNNING_AVG_N(avg,val) DO_RUNNING_AVG(avg,val,4)
125 void QualityControlRender_Start(QualityControlImpl
*This
, REFERENCE_TIME tStart
)
127 TRACE("%p " XTIME_FMT
"\n", This
, XTIME(tStart
));
128 This
->avg_render
= This
->last_in_time
= This
->last_left
= This
->avg_duration
= This
->avg_pt
= -1;
129 This
->clockstart
= tStart
;
130 This
->avg_rate
= -1.0;
131 This
->rendered
= This
->dropped
= 0;
132 This
->is_dropped
= FALSE
;
133 This
->qos_handled
= TRUE
; /* Lie that will be corrected on first adjustment */
137 void QualityControlRender_SetClock(QualityControlImpl
*This
, IReferenceClock
*clock
)
139 TRACE("%p %p\n", This
, clock
);
143 static BOOL
QualityControlRender_IsLate(QualityControlImpl
*This
, REFERENCE_TIME jitter
,
144 REFERENCE_TIME start
, REFERENCE_TIME stop
)
146 REFERENCE_TIME max_lateness
= 200000;
148 TRACE("%p " XTIME_FMT
" " XTIME_FMT
" " XTIME_FMT
"\n",
149 This
, XTIME(jitter
), XTIME(start
), XTIME(stop
));
151 /* we can add a valid stop time */
153 max_lateness
+= stop
;
155 max_lateness
+= start
;
157 /* if the jitter bigger than duration and lateness we are too late */
158 if (start
+ jitter
> max_lateness
) {
159 WARN("buffer is too late %i > %i\n", (int)((start
+ jitter
)/10000), (int)(max_lateness
/10000));
160 /* !!emergency!!, if we did not receive anything valid for more than a
161 * second, render it anyway so the user sees something */
162 if (This
->last_in_time
< 0 ||
163 start
- This
->last_in_time
< 10000000)
165 FIXME("A lot of buffers are being dropped.\n");
166 FIXME("There may be a timestamping problem, or this computer is too slow.\n");
168 This
->last_in_time
= start
;
172 HRESULT
QualityControlRender_WaitFor(QualityControlImpl
*This
, IMediaSample
*sample
, HANDLE ev
)
174 REFERENCE_TIME start
= -1, stop
= -1, jitter
= 0;
176 TRACE("%p %p %p\n", This
, sample
, ev
);
178 This
->current_rstart
= This
->current_rstop
= -1;
179 This
->current_jitter
= 0;
180 if (!This
->clock
|| FAILED(IMediaSample_GetTime(sample
, &start
, &stop
)))
185 IReferenceClock_GetTime(This
->clock
, &now
);
186 now
-= This
->clockstart
;
188 jitter
= now
- start
;
189 if (jitter
<= -10000) {
191 IReferenceClock_AdviseTime(This
->clock
, This
->clockstart
, start
, (HEVENT
)ev
, &cookie
);
192 WaitForSingleObject(ev
, INFINITE
);
193 IReferenceClock_Unadvise(This
->clock
, cookie
);
198 This
->current_rstart
= start
;
199 This
->current_rstop
= stop
> start
? stop
: start
;
200 This
->current_jitter
= jitter
;
201 This
->is_dropped
= QualityControlRender_IsLate(This
, jitter
, start
, stop
);
202 TRACE("Dropped: %i %i %i %i\n", This
->is_dropped
, (int)(start
/10000), (int)(stop
/10000), (int)(jitter
/ 10000));
203 if (This
->is_dropped
) {
205 if (!This
->qos_handled
)
212 void QualityControlRender_DoQOS(QualityControlImpl
*priv
)
214 REFERENCE_TIME start
, stop
, jitter
, pt
, entered
, left
, duration
;
219 if (!priv
->clock
|| priv
->current_rstart
< 0)
222 start
= priv
->current_rstart
;
223 stop
= priv
->current_rstop
;
224 jitter
= priv
->current_jitter
;
227 /* this is the time the buffer entered the sink */
231 entered
= start
+ jitter
;
234 /* this is the time the buffer entered the sink */
235 entered
= start
+ jitter
;
236 /* this is the time the buffer left the sink */
237 left
= start
+ jitter
;
240 /* calculate duration of the buffer */
242 duration
= stop
- start
;
246 /* if we have the time when the last buffer left us, calculate
248 if (priv
->last_left
>= 0) {
249 if (entered
> priv
->last_left
) {
250 pt
= entered
- priv
->last_left
;
258 TRACE("start: " XTIME_FMT
", entered " XTIME_FMT
", left " XTIME_FMT
", pt: " XTIME_FMT
", "
259 "duration " XTIME_FMT
", jitter " XTIME_FMT
"\n", XTIME(start
), XTIME(entered
),
260 XTIME(left
), XTIME(pt
), XTIME(duration
), XTIME(jitter
));
262 TRACE("avg_duration: " XTIME_FMT
", avg_pt: " XTIME_FMT
", avg_rate: %g\n",
263 XTIME(priv
->avg_duration
), XTIME(priv
->avg_pt
), priv
->avg_rate
);
265 /* collect running averages. for first observations, we copy the
267 if (priv
->avg_duration
< 0)
268 priv
->avg_duration
= duration
;
270 priv
->avg_duration
= UPDATE_RUNNING_AVG (priv
->avg_duration
, duration
);
272 if (priv
->avg_pt
< 0)
275 priv
->avg_pt
= UPDATE_RUNNING_AVG (priv
->avg_pt
, pt
);
277 if (priv
->avg_duration
!= 0)
279 (double)priv
->avg_pt
/
280 (double)priv
->avg_duration
;
284 if (priv
->last_left
>= 0) {
285 if (priv
->is_dropped
|| priv
->avg_rate
< 0.0) {
286 priv
->avg_rate
= rate
;
289 priv
->avg_rate
= UPDATE_RUNNING_AVG_N (priv
->avg_rate
, rate
);
291 priv
->avg_rate
= UPDATE_RUNNING_AVG_P (priv
->avg_rate
, rate
);
295 if (priv
->avg_rate
>= 0.0) {
298 /* if we have a valid rate, start sending QoS messages */
299 if (priv
->current_jitter
< 0) {
300 /* make sure we never go below 0 when adding the jitter to the
302 if (priv
->current_rstart
< -priv
->current_jitter
)
303 priv
->current_jitter
= -priv
->current_rstart
;
306 priv
->current_jitter
+= (priv
->current_rstop
- priv
->current_rstart
);
307 q
.Type
= (jitter
> 0 ? Famine
: Flood
);
308 q
.Proportion
= (LONG
)(1000. / priv
->avg_rate
);
309 if (q
.Proportion
< 200)
311 else if (q
.Proportion
> 5000)
313 q
.Late
= priv
->current_jitter
;
314 q
.TimeStamp
= priv
->current_rstart
;
315 TRACE("Late: %i from %i, rate: %g\n", (int)(q
.Late
/10000), (int)(q
.TimeStamp
/10000), 1./priv
->avg_rate
);
316 hr
= IQualityControl_Notify(&priv
->IQualityControl_iface
, priv
->self
, q
);
317 priv
->qos_handled
= hr
== S_OK
;
320 /* record when this buffer will leave us */
321 priv
->last_left
= left
;
325 void QualityControlRender_BeginRender(QualityControlImpl
*This
)
334 IReferenceClock_GetTime(This
->clock
, &This
->start
);
335 TRACE("at: " XTIME_FMT
"\n", XTIME(This
->start
));
338 void QualityControlRender_EndRender(QualityControlImpl
*This
)
340 REFERENCE_TIME elapsed
;
344 if (!This
->clock
|| This
->start
< 0 || FAILED(IReferenceClock_GetTime(This
->clock
, &This
->stop
)))
347 elapsed
= This
->start
- This
->stop
;
350 if (This
->avg_render
< 0)
351 This
->avg_render
= elapsed
;
353 This
->avg_render
= UPDATE_RUNNING_AVG (This
->avg_render
, elapsed
);