1 /*****************************************************************************
2 * decoder_synchro.c : frame dropping routines
3 *****************************************************************************
4 * Copyright (C) 1999-2005 VLC authors and VideoLAN
7 * Authors: Christophe Massiot <massiot@via.ecp.fr>
8 * Samuel Hocevar <sam@via.ecp.fr>
9 * Jean-Marc Dressler <polux@via.ecp.fr>
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation; either version 2.1 of the License, or
14 * (at your option) any later version.
16 * This program 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
19 * GNU Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public License
22 * along with this program; if not, write to the Free Software Foundation,
23 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
27 * DISCUSSION : How to Write an efficient Frame-Dropping Algorithm
30 * This implementation is based on mathematical and statistical
31 * developments. Older implementations used an enslavement, considering
32 * that if we're late when reading an I picture, we will decode one frame
33 * less. It had a tendency to derive, and wasn't responsive enough, which
34 * would have caused trouble with the stream control stuff.
36 * 1. Structure of a picture stream
37 * =============================
38 * Between 2 I's, we have for instance :
39 * I B P B P B P B P B P B I
40 * t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12
41 * Please bear in mind that B's and IP's will be inverted when displaying
42 * (decoding order != presentation order). Thus, t1 < t0.
46 * t[0..12] : Presentation timestamps of pictures 0..12.
47 * t : Current timestamp, at the moment of the decoding.
48 * T : Picture period, T = 1/frame_rate.
49 * tau[I,P,B] : Mean time to decode an [I,P,B] picture.
50 * tauYUV : Mean time to render a picture (given by the video_output).
51 * tau´[I,P,B] = 2 * tau[I,P,B] + tauYUV
52 * : Mean time + typical difference (estimated to tau/2, that
53 * needs to be confirmed) + render time.
54 * DELTA : A given error margin.
56 * 3. General considerations
57 * ======================
58 * We define three types of machines :
59 * 14T > tauI : machines capable of decoding all I pictures
60 * 2T > tauP : machines capable of decoding all P pictures
61 * T > tauB : machines capable of decoding all B pictures
63 * 4. Decoding of an I picture
64 * ========================
65 * On fast machines, we decode all I's.
67 * We can decode an I picture if we simply have enough time to decode it
69 * t0 - t > tau´I + DELTA
71 * 5. Decoding of a P picture
72 * =======================
73 * On fast machines, we decode all P's.
75 * First criterion : have time to decode it.
76 * t2 - t > tau´P + DELTA
78 * Second criterion : it shouldn't prevent us from displaying the forthcoming
79 * I picture, which is more important.
80 * t12 - t > tau´P + tau´I + DELTA
82 * 6. Decoding of a B picture
83 * =======================
84 * On fast machines, we decode all B's. Otherwise :
85 * t1 - t > tau´B + DELTA
86 * Since the next displayed I or P is already decoded, we don't have to
89 * I hope you will have a pleasant flight and do not forget your life
91 * --Meuuh (2000-12-29)
94 /*****************************************************************************
96 *****************************************************************************/
101 #include <vlc_common.h>
102 #include <vlc_input.h>
103 #include <vlc_codec.h>
110 #define MAX_PIC_AVERAGE 8
112 struct decoder_synchro_t
122 /* date of the beginning of the decoding of the current picture */
123 mtime_t decoding_start
;
125 /* stream properties */
126 unsigned int i_n_p
, i_n_b
;
128 /* decoding values */
129 mtime_t p_tau
[4]; /* average decoding durations */
130 unsigned int pi_meaningful
[4]; /* number of durations read */
132 /* render_time filled by SynchroChoose() */
136 int i_nb_ref
; /* Number of reference pictures */
137 int i_dec_nb_ref
; /* Number of reference pictures we'll *
138 * have if we decode the current pic */
139 int i_trash_nb_ref
; /* Number of reference pictures we'll *
140 * have if we trash the current pic */
141 unsigned int i_eta_p
, i_eta_b
;
142 mtime_t backward_pts
, current_pts
;
143 int i_current_period
; /* period to add to the next picture */
144 int i_backward_period
; /* period to add after the next
146 * (backward_period * period / 2) */
149 unsigned int i_trashed_pic
, i_not_chosen_pic
, i_pic
;
153 #define DELTA (int)(0.075*CLOCK_FREQ)
154 #define MAX_VALID_TAU (int)(0.3*CLOCK_FREQ)
156 #define DEFAULT_NB_P 5
157 #define DEFAULT_NB_B 1
159 /*****************************************************************************
160 * decoder_SynchroInit : You know what ?
161 *****************************************************************************/
162 decoder_synchro_t
* decoder_SynchroInit( decoder_t
*p_dec
, int i_frame_rate
)
164 decoder_synchro_t
* p_synchro
= calloc( 1, sizeof(*p_synchro
) );
168 p_synchro
->p_dec
= p_dec
;
169 p_synchro
->b_no_skip
= !var_InheritBool( p_dec
, "skip-frames" );
170 p_synchro
->b_quiet
= var_InheritBool( p_dec
, "quiet-synchro" );
172 /* We use a fake stream pattern, which is often right. */
173 p_synchro
->i_n_p
= p_synchro
->i_eta_p
= DEFAULT_NB_P
;
174 p_synchro
->i_n_b
= p_synchro
->i_eta_b
= DEFAULT_NB_B
;
175 memset( p_synchro
->p_tau
, 0, 4 * sizeof(mtime_t
) );
176 memset( p_synchro
->pi_meaningful
, 0, 4 * sizeof(unsigned int) );
177 p_synchro
->i_nb_ref
= 0;
178 p_synchro
->i_trash_nb_ref
= p_synchro
->i_dec_nb_ref
= 0;
179 p_synchro
->current_pts
= 1,
180 p_synchro
->backward_pts
= 0;
181 p_synchro
->i_current_period
= p_synchro
->i_backward_period
= 0;
182 p_synchro
->i_trashed_pic
= p_synchro
->i_not_chosen_pic
=
183 p_synchro
->i_pic
= 0;
185 p_synchro
->i_frame_rate
= i_frame_rate
;
190 /*****************************************************************************
191 * decoder_SynchroRelease : You know what ?
192 *****************************************************************************/
193 void decoder_SynchroRelease( decoder_synchro_t
* p_synchro
)
198 /*****************************************************************************
199 * decoder_SynchroReset : Reset the reference picture counter
200 *****************************************************************************/
201 void decoder_SynchroReset( decoder_synchro_t
* p_synchro
)
203 p_synchro
->i_nb_ref
= 0;
204 p_synchro
->i_trash_nb_ref
= p_synchro
->i_dec_nb_ref
= 0;
207 /*****************************************************************************
208 * decoder_SynchroChoose : Decide whether we will decode a picture or not
209 *****************************************************************************/
210 bool decoder_SynchroChoose( decoder_synchro_t
* p_synchro
, int i_coding_type
,
211 int i_render_time
, bool b_low_delay
)
213 #define TAU_PRIME( coding_type ) (p_synchro->p_tau[(coding_type)] \
214 + (p_synchro->p_tau[(coding_type)] >> 1) \
215 + p_synchro->i_render_time)
216 #define S (*p_synchro)
222 if ( p_synchro
->b_no_skip
)
225 i_current_rate
= decoder_GetDisplayRate( p_synchro
->p_dec
);
228 period
= CLOCK_FREQ
* 1001 / p_synchro
->i_frame_rate
229 * i_current_rate
/ INPUT_RATE_DEFAULT
;
231 p_synchro
->i_render_time
= i_render_time
;
233 switch( i_coding_type
)
238 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.current_pts
);
240 else if( S
.backward_pts
)
242 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.backward_pts
);
246 /* displaying order : B B P B B I
248 * | +- current picture
251 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.current_pts
) + period
* (S
.i_n_b
+ 2);
254 if( (1 + S
.i_n_p
* (S
.i_n_b
+ 1)) * period
> S
.p_tau
[I_CODING_TYPE
] )
260 b_decode
= (pts
- now
) > (TAU_PRIME(I_CODING_TYPE
) + DELTA
);
262 if( pts
<= VLC_TS_INVALID
)
265 if( !b_decode
&& !p_synchro
->b_quiet
)
267 msg_Warn( p_synchro
->p_dec
,
268 "synchro trashing I (%"PRId64
")", pts
- now
);
275 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.current_pts
);
277 else if( S
.backward_pts
)
279 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.backward_pts
);
283 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.current_pts
+ period
* (S
.i_n_b
+ 1) );
286 if( p_synchro
->i_nb_ref
< 1 )
290 else if( (1 + S
.i_n_p
* (S
.i_n_b
+ 1)) * period
>
291 S
.p_tau
[I_CODING_TYPE
] )
293 if( (S
.i_n_b
+ 1) * period
> S
.p_tau
[P_CODING_TYPE
] )
295 /* Security in case we're _really_ late */
296 b_decode
= (pts
- now
> 0);
300 b_decode
= (pts
- now
) > (TAU_PRIME(P_CODING_TYPE
) + DELTA
);
302 b_decode
&= (pts
- now
304 * ( (S
.i_n_p
- S
.i_eta_p
) * (1 + S
.i_n_b
) - 1 ))
305 > (TAU_PRIME(P_CODING_TYPE
)
306 + TAU_PRIME(I_CODING_TYPE
) + DELTA
);
313 if( p_synchro
->i_nb_ref
>= 1 && pts
<= VLC_TS_INVALID
)
318 pts
= decoder_GetDisplayDate( p_synchro
->p_dec
, S
.current_pts
);
320 if( p_synchro
->i_nb_ref
< 2 )
324 else if( (S
.i_n_b
+ 1) * period
> S
.p_tau
[P_CODING_TYPE
] )
326 b_decode
= (pts
- now
) > (TAU_PRIME(B_CODING_TYPE
) + DELTA
);
332 if( p_synchro
->i_nb_ref
>= 2 && pts
<= VLC_TS_INVALID
)
339 S
.i_not_chosen_pic
++;
346 /*****************************************************************************
347 * decoder_SynchroTrash : Update counters when we trash a picture
348 *****************************************************************************/
349 void decoder_SynchroTrash( decoder_synchro_t
* p_synchro
)
351 p_synchro
->i_trashed_pic
++;
352 p_synchro
->i_nb_ref
= p_synchro
->i_trash_nb_ref
;
355 /*****************************************************************************
356 * decoder_SynchroDecode : Update timers when we decide to decode a picture
357 *****************************************************************************/
358 void decoder_SynchroDecode( decoder_synchro_t
* p_synchro
)
360 p_synchro
->decoding_start
= mdate();
361 p_synchro
->i_nb_ref
= p_synchro
->i_dec_nb_ref
;
364 /*****************************************************************************
365 * decoder_SynchroEnd : Called when the image is totally decoded
366 *****************************************************************************/
367 void decoder_SynchroEnd( decoder_synchro_t
* p_synchro
, int i_coding_type
,
375 tau
= mdate() - p_synchro
->decoding_start
;
377 /* If duration too high, something happened (pause ?), so don't
378 * take it into account. */
379 if( tau
< 3 * p_synchro
->p_tau
[i_coding_type
] ||
380 ( !p_synchro
->pi_meaningful
[i_coding_type
] && tau
< MAX_VALID_TAU
) )
382 /* Mean with average tau, to ensure stability. */
383 p_synchro
->p_tau
[i_coding_type
] =
384 (p_synchro
->pi_meaningful
[i_coding_type
]
385 * p_synchro
->p_tau
[i_coding_type
] + tau
)
386 / (p_synchro
->pi_meaningful
[i_coding_type
] + 1);
387 if( p_synchro
->pi_meaningful
[i_coding_type
] < MAX_PIC_AVERAGE
)
389 p_synchro
->pi_meaningful
[i_coding_type
]++;
394 /*****************************************************************************
395 * decoder_SynchroDate : When an image has been decoded, ask for its date
396 *****************************************************************************/
397 mtime_t
decoder_SynchroDate( decoder_synchro_t
* p_synchro
)
399 /* No need to lock, since PTS are only used by the video parser. */
400 return p_synchro
->current_pts
;
403 /*****************************************************************************
404 * decoder_SynchroNewPicture: Update stream structure and PTS
405 *****************************************************************************/
406 void decoder_SynchroNewPicture( decoder_synchro_t
* p_synchro
, int i_coding_type
,
407 int i_repeat_field
, mtime_t next_pts
,
408 mtime_t next_dts
, bool b_low_delay
)
410 mtime_t period
= 1000000 * 1001 / p_synchro
->i_frame_rate
;
412 mtime_t now
= mdate();
415 switch( i_coding_type
)
418 if( p_synchro
->i_eta_p
&& p_synchro
->i_eta_p
!= p_synchro
->i_n_p
)
421 if( !p_synchro
->b_quiet
)
422 msg_Dbg( p_synchro
->p_dec
,
423 "stream periodicity changed from P[%d] to P[%d]",
424 p_synchro
->i_n_p
, p_synchro
->i_eta_p
);
426 p_synchro
->i_n_p
= p_synchro
->i_eta_p
;
428 p_synchro
->i_eta_p
= p_synchro
->i_eta_b
= 0;
429 p_synchro
->i_trash_nb_ref
= 0;
430 if( p_synchro
->i_nb_ref
< 2 )
431 p_synchro
->i_dec_nb_ref
= p_synchro
->i_nb_ref
+ 1;
433 p_synchro
->i_dec_nb_ref
= p_synchro
->i_nb_ref
;
436 if( !p_synchro
->b_quiet
)
437 msg_Dbg( p_synchro
->p_dec
, "I(%"PRId64
") P(%"PRId64
")[%d] B(%"PRId64
")"
438 "[%d] YUV(%"PRId64
") : trashed %d:%d/%d",
439 p_synchro
->p_tau
[I_CODING_TYPE
],
440 p_synchro
->p_tau
[P_CODING_TYPE
],
442 p_synchro
->p_tau
[B_CODING_TYPE
],
444 p_synchro
->i_render_time
,
445 p_synchro
->i_not_chosen_pic
,
446 p_synchro
->i_trashed_pic
-
447 p_synchro
->i_not_chosen_pic
,
449 p_synchro
->i_trashed_pic
= p_synchro
->i_not_chosen_pic
450 = p_synchro
->i_pic
= 0;
452 if( p_synchro
->i_pic
>= 100 )
454 if( !p_synchro
->b_quiet
&& p_synchro
->i_trashed_pic
!= 0 )
455 msg_Dbg( p_synchro
->p_dec
, "decoded %d/%d pictures",
457 - p_synchro
->i_trashed_pic
,
459 p_synchro
->i_trashed_pic
= p_synchro
->i_not_chosen_pic
460 = p_synchro
->i_pic
= 0;
466 p_synchro
->i_eta_p
++;
467 if( p_synchro
->i_eta_b
468 && p_synchro
->i_eta_b
!= p_synchro
->i_n_b
)
471 if( !p_synchro
->b_quiet
)
472 msg_Dbg( p_synchro
->p_dec
,
473 "stream periodicity changed from B[%d] to B[%d]",
474 p_synchro
->i_n_b
, p_synchro
->i_eta_b
);
476 p_synchro
->i_n_b
= p_synchro
->i_eta_b
;
478 p_synchro
->i_eta_b
= 0;
479 p_synchro
->i_dec_nb_ref
= 2;
480 p_synchro
->i_trash_nb_ref
= 0;
484 p_synchro
->i_eta_b
++;
485 p_synchro
->i_dec_nb_ref
= p_synchro
->i_trash_nb_ref
486 = p_synchro
->i_nb_ref
;
490 p_synchro
->current_pts
+= p_synchro
->i_current_period
493 #define PTS_THRESHOLD (period >> 2)
494 if( i_coding_type
== B_CODING_TYPE
|| b_low_delay
)
496 /* A video frame can be displayed 1, 2 or 3 times, according to
497 * repeat_first_field, top_field_first, progressive_sequence and
498 * progressive_frame. */
499 p_synchro
->i_current_period
= i_repeat_field
;
503 if( (next_pts
- p_synchro
->current_pts
505 || p_synchro
->current_pts
- next_pts
506 > PTS_THRESHOLD
) && !p_synchro
->b_quiet
)
508 msg_Warn( p_synchro
->p_dec
, "decoder synchro warning: pts != "
509 "current_date (%"PRId64
")",
510 p_synchro
->current_pts
513 p_synchro
->current_pts
= next_pts
;
518 p_synchro
->i_current_period
= p_synchro
->i_backward_period
;
519 p_synchro
->i_backward_period
= i_repeat_field
;
521 if( p_synchro
->backward_pts
)
524 (next_dts
- p_synchro
->backward_pts
526 || p_synchro
->backward_pts
- next_dts
527 > PTS_THRESHOLD
) && !p_synchro
->b_quiet
)
529 msg_Warn( p_synchro
->p_dec
, "backward_pts != dts (%"PRId64
")",
531 - p_synchro
->backward_pts
);
533 if( (p_synchro
->backward_pts
- p_synchro
->current_pts
535 || p_synchro
->current_pts
- p_synchro
->backward_pts
536 > PTS_THRESHOLD
) && !p_synchro
->b_quiet
)
538 msg_Warn( p_synchro
->p_dec
,
539 "backward_pts != current_pts (%"PRId64
")",
540 p_synchro
->current_pts
541 - p_synchro
->backward_pts
);
543 p_synchro
->current_pts
= p_synchro
->backward_pts
;
544 p_synchro
->backward_pts
= 0;
548 if( (next_dts
- p_synchro
->current_pts
550 || p_synchro
->current_pts
- next_dts
551 > PTS_THRESHOLD
) && !p_synchro
->b_quiet
)
553 msg_Warn( p_synchro
->p_dec
, "dts != current_pts (%"PRId64
")",
554 p_synchro
->current_pts
557 /* By definition of a DTS. */
558 p_synchro
->current_pts
= next_dts
;
564 /* Store the PTS for the next time we have to date an I picture. */
565 p_synchro
->backward_pts
= next_pts
;
572 /* Removed for incompatibility with slow motion */
573 if( p_synchro
->current_pts
+ DEFAULT_PTS_DELAY
< now
)
575 /* We cannot be _that_ late, something must have happened, reinit
577 if( !p_synchro
->b_quiet
)
578 msg_Warn( p_synchro
->p_dec
, "PTS << now (%"PRId64
"), resetting",
579 now
- p_synchro
->current_pts
- DEFAULT_PTS_DELAY
);
580 p_synchro
->current_pts
= now
+ DEFAULT_PTS_DELAY
;
582 if( p_synchro
->backward_pts
583 && p_synchro
->backward_pts
+ DEFAULT_PTS_DELAY
< now
)
586 p_synchro
->backward_pts
= 0;