decoder_synchro.c 20.6 KB
Newer Older
1
/*****************************************************************************
2
 * decoder_synchro.c : frame dropping routines
3
 *****************************************************************************
4
 * Copyright (C) 1999-2005 the VideoLAN team
5
 * $Id$
6 7 8 9 10 11 12 13 14
 *
 * Authors: Christophe Massiot <massiot@via.ecp.fr>
 *          Samuel Hocevar <sam@via.ecp.fr>
 *          Jean-Marc Dressler <polux@via.ecp.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
15
 *
16 17 18 19 20 21 22
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
Antoine Cellerier's avatar
Antoine Cellerier committed
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 *****************************************************************************/

/*
 * DISCUSSION : How to Write an efficient Frame-Dropping Algorithm
 * ==========
 *
 * This implementation is based on mathematical and statistical
 * developments. Older implementations used an enslavement, considering
 * that if we're late when reading an I picture, we will decode one frame
 * less. It had a tendancy to derive, and wasn't responsive enough, which
 * would have caused trouble with the stream control stuff.
 *
 * 1. Structure of a picture stream
 *    =============================
 * Between 2 I's, we have for instance :
 *    I   B   P   B   P   B   P   B   P   B   P   B   I
 *    t0  t1  t2  t3  t4  t5  t6  t7  t8  t9  t10 t11 t12
 * Please bear in mind that B's and IP's will be inverted when displaying
 * (decoding order != presentation order). Thus, t1 < t0.
 *
 * 2. Definitions
 *    ===========
 * t[0..12]     : Presentation timestamps of pictures 0..12.
 * t            : Current timestamp, at the moment of the decoding.
 * T            : Picture period, T = 1/frame_rate.
 * tau[I,P,B]   : Mean time to decode an [I,P,B] picture.
 * tauYUV       : Mean time to render a picture (given by the video_output).
51
 * tau´[I,P,B] = 2 * tau[I,P,B] + tauYUV
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
 *              : Mean time + typical difference (estimated to tau/2, that
 *                needs to be confirmed) + render time.
 * DELTA        : A given error margin.
 *
 * 3. General considerations
 *    ======================
 * We define three types of machines :
 *      14T > tauI : machines capable of decoding all I pictures
 *      2T > tauP  : machines capable of decoding all P pictures
 *      T > tauB   : machines capable of decoding all B pictures
 *
 * 4. Decoding of an I picture
 *    ========================
 * On fast machines, we decode all I's.
 * Otherwise :
Clément Stenac's avatar
Clément Stenac committed
67
 * We can decode an I picture if we simply have enough time to decode it
68
 * before displaying :
69
 *      t0 - t > tau´I + DELTA
70 71 72 73 74 75
 *
 * 5. Decoding of a P picture
 *    =======================
 * On fast machines, we decode all P's.
 * Otherwise :
 * First criterion : have time to decode it.
76
 *      t2 - t > tau´P + DELTA
77 78 79
 *
 * Second criterion : it shouldn't prevent us from displaying the forthcoming
 * I picture, which is more important.
80
 *      t12 - t > tau´P + tau´I + DELTA
81 82 83 84
 *
 * 6. Decoding of a B picture
 *    =======================
 * On fast machines, we decode all B's. Otherwise :
85
 *      t1 - t > tau´B + DELTA
86 87 88 89 90 91 92 93 94 95 96
 * Since the next displayed I or P is already decoded, we don't have to
 * worry about it.
 *
 * I hope you will have a pleasant flight and do not forget your life
 * jacket.
 *                                                  --Meuuh (2000-12-29)
 */

/*****************************************************************************
 * Preamble
 *****************************************************************************/
97 98 99 100
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

101
#include <vlc_common.h>
Clément Stenac's avatar
Clément Stenac committed
102
#include <vlc_input.h>
Laurent Aimar's avatar
Laurent Aimar committed
103
#include <vlc_codec.h>
104
#include <vlc_codec_synchro.h>
105 106 107 108 109

/*
 * Local prototypes
 */

Laurent Aimar's avatar
Laurent Aimar committed
110 111
#define MAX_PIC_AVERAGE         8

112
struct decoder_synchro_t
Laurent Aimar's avatar
Laurent Aimar committed
113
{
114 115
    /* */
    decoder_t       *p_dec;
Laurent Aimar's avatar
Laurent Aimar committed
116

117
    /* */
Laurent Aimar's avatar
Laurent Aimar committed
118
    int             i_frame_rate;
119 120
    bool      b_no_skip;
    bool      b_quiet;
Laurent Aimar's avatar
Laurent Aimar committed
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151

    /* date of the beginning of the decoding of the current picture */
    mtime_t         decoding_start;

    /* stream properties */
    unsigned int    i_n_p, i_n_b;

    /* decoding values */
    mtime_t         p_tau[4];                  /* average decoding durations */
    unsigned int    pi_meaningful[4];            /* number of durations read */

    /* render_time filled by SynchroChoose() */
    int i_render_time;

    /* stream context */
    int             i_nb_ref;                /* Number of reference pictures */
    int             i_dec_nb_ref;      /* Number of reference pictures we'll *
                                        * have if we decode the current pic  */
    int             i_trash_nb_ref;    /* Number of reference pictures we'll *
                                        * have if we trash the current pic   */
    unsigned int    i_eta_p, i_eta_b;
    mtime_t         backward_pts, current_pts;
    int             i_current_period;   /* period to add to the next picture */
    int             i_backward_period;  /* period to add after the next
                                         * reference picture
                                         * (backward_period * period / 2) */

    /* statistics */
    unsigned int    i_trashed_pic, i_not_chosen_pic, i_pic;
};

152 153
/* Error margins */
#define DELTA                   (int)(0.075*CLOCK_FREQ)
154
#define MAX_VALID_TAU           (int)(0.3*CLOCK_FREQ)
155 156 157 158 159

#define DEFAULT_NB_P            5
#define DEFAULT_NB_B            1

/*****************************************************************************
160
 * decoder_SynchroInit : You know what ?
161
 *****************************************************************************/
162
decoder_synchro_t * decoder_SynchroInit( decoder_t *p_dec, int i_frame_rate )
163
{
Rémi Duraffort's avatar
Rémi Duraffort committed
164 165
    decoder_synchro_t * p_synchro = calloc( 1, sizeof(*p_synchro) );
    if( !p_synchro )
166 167
        return NULL;

168
    p_synchro->p_dec = p_dec;
169 170
    p_synchro->b_no_skip = !config_GetInt( p_dec, "skip-frames" );
    p_synchro->b_quiet = config_GetInt( p_dec, "quiet-synchro" );
171

172 173 174 175 176 177
    /* We use a fake stream pattern, which is often right. */
    p_synchro->i_n_p = p_synchro->i_eta_p = DEFAULT_NB_P;
    p_synchro->i_n_b = p_synchro->i_eta_b = DEFAULT_NB_B;
    memset( p_synchro->p_tau, 0, 4 * sizeof(mtime_t) );
    memset( p_synchro->pi_meaningful, 0, 4 * sizeof(unsigned int) );
    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 181
    p_synchro->backward_pts = 0;
    p_synchro->i_current_period = p_synchro->i_backward_period = 0;
Clément Stenac's avatar
Clément Stenac committed
182
    p_synchro->i_trashed_pic = p_synchro->i_not_chosen_pic =
183 184 185 186 187 188 189 190
        p_synchro->i_pic = 0;

    p_synchro->i_frame_rate = i_frame_rate;

    return p_synchro;
}

/*****************************************************************************
191
 * decoder_SynchroRelease : You know what ?
192
 *****************************************************************************/
193
void decoder_SynchroRelease( decoder_synchro_t * p_synchro )
194
{
195
    free( p_synchro );
196 197 198
}

/*****************************************************************************
199
 * decoder_SynchroReset : Reset the reference picture counter
200
 *****************************************************************************/
201
void decoder_SynchroReset( decoder_synchro_t * p_synchro )
202 203
{
    p_synchro->i_nb_ref = 0;
204
    p_synchro->i_trash_nb_ref = p_synchro->i_dec_nb_ref = 0;
205 206 207
}

/*****************************************************************************
208
 * decoder_SynchroChoose : Decide whether we will decode a picture or not
209
 *****************************************************************************/
210 211
bool decoder_SynchroChoose( decoder_synchro_t * p_synchro, int i_coding_type,
                               int i_render_time, bool b_low_delay )
212 213 214
{
#define TAU_PRIME( coding_type )    (p_synchro->p_tau[(coding_type)] \
                                    + (p_synchro->p_tau[(coding_type)] >> 1) \
215
                                    + p_synchro->i_render_time)
216
#define S (*p_synchro)
217
    mtime_t         now, period;
218
    mtime_t         pts = 0;
219
    bool      b_decode = 0;
220
    int       i_current_rate;
221

222 223 224
    if ( p_synchro->b_no_skip )
        return 1;

225 226
    i_current_rate = decoder_GetDisplayRate( p_synchro->p_dec );

227 228
    now = mdate();
    period = 1000000 * 1001 / p_synchro->i_frame_rate
229
                     * i_current_rate / INPUT_RATE_DEFAULT;
230

231
    p_synchro->i_render_time = i_render_time;
232 233 234 235

    switch( i_coding_type )
    {
    case I_CODING_TYPE:
236 237
        if( b_low_delay )
        {
238
            pts = decoder_GetDisplayDate( p_synchro->p_dec, S.current_pts );
239 240
        }
        else if( S.backward_pts )
241
        {
242
            pts = decoder_GetDisplayDate( p_synchro->p_dec, S.backward_pts );
243 244 245 246 247 248 249 250
        }
        else
        {
            /* displaying order : B B P B B I
             *                      ^       ^
             *                      |       +- current picture
             *                      +- current PTS
             */
251
            pts = decoder_GetDisplayDate( p_synchro->p_dec, S.current_pts ) + period * (S.i_n_b + 2);
252 253 254 255 256 257 258 259 260 261 262
        }

        if( (1 + S.i_n_p * (S.i_n_b + 1)) * period >
                S.p_tau[I_CODING_TYPE] )
        {
            b_decode = 1;
        }
        else
        {
            b_decode = (pts - now) > (TAU_PRIME(I_CODING_TYPE) + DELTA);
        }
263
        if( !b_decode && !p_synchro->b_quiet )
264
        {
265
            msg_Warn( p_synchro->p_dec,
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
266
                      "synchro trashing I (%"PRId64")", pts - now );
267 268 269 270
        }
        break;

    case P_CODING_TYPE:
271 272
        if( b_low_delay )
        {
273
            pts = decoder_GetDisplayDate( p_synchro->p_dec, S.current_pts );
274 275
        }
        else if( S.backward_pts )
276
        {
277
            pts = decoder_GetDisplayDate( p_synchro->p_dec, S.backward_pts );
278 279 280
        }
        else
        {
281
            pts = decoder_GetDisplayDate( p_synchro->p_dec, S.current_pts + period * (S.i_n_b + 1) );
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
        }

        if( p_synchro->i_nb_ref < 1 )
        {
            b_decode = 0;
        }
        else if( (1 + S.i_n_p * (S.i_n_b + 1)) * period >
                S.p_tau[I_CODING_TYPE] )
        {
            if( (S.i_n_b + 1) * period > S.p_tau[P_CODING_TYPE] )
            {
                /* Security in case we're _really_ late */
                b_decode = (pts - now > 0);
            }
            else
            {
                b_decode = (pts - now) > (TAU_PRIME(P_CODING_TYPE) + DELTA);
                /* next I */
                b_decode &= (pts - now
                              + period
                          * ( (S.i_n_p - S.i_eta_p) * (1 + S.i_n_b) - 1 ))
                            > (TAU_PRIME(P_CODING_TYPE)
                                + TAU_PRIME(I_CODING_TYPE) + DELTA);
            }
        }
        else
        {
            b_decode = 0;
        }
        break;

    case B_CODING_TYPE:
314
        pts = decoder_GetDisplayDate( p_synchro->p_dec, S.current_pts );
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

        if( p_synchro->i_nb_ref < 2 )
        {
            b_decode = 0;
        }
        else if( (S.i_n_b + 1) * period > S.p_tau[P_CODING_TYPE] )
        {
            b_decode = (pts - now) > (TAU_PRIME(B_CODING_TYPE) + DELTA);
        }
        else
        {
            b_decode = 0;
        }
    }

    if( !b_decode )
    {
        S.i_not_chosen_pic++;
    }
    return( b_decode );
#undef S
#undef TAU_PRIME
}

/*****************************************************************************
340
 * decoder_SynchroTrash : Update counters when we trash a picture
341
 *****************************************************************************/
342
void decoder_SynchroTrash( decoder_synchro_t * p_synchro )
343 344
{
    p_synchro->i_trashed_pic++;
345
    p_synchro->i_nb_ref = p_synchro->i_trash_nb_ref;
346 347 348
}

/*****************************************************************************
349
 * decoder_SynchroDecode : Update timers when we decide to decode a picture
350
 *****************************************************************************/
351
void decoder_SynchroDecode( decoder_synchro_t * p_synchro )
352 353
{
    p_synchro->decoding_start = mdate();
354
    p_synchro->i_nb_ref = p_synchro->i_dec_nb_ref;
355 356 357
}

/*****************************************************************************
358
 * decoder_SynchroEnd : Called when the image is totally decoded
359
 *****************************************************************************/
360
void decoder_SynchroEnd( decoder_synchro_t * p_synchro, int i_coding_type,
361
                      bool b_garbage )
362 363 364 365 366 367 368 369 370 371
{
    mtime_t     tau;

    if( !b_garbage )
    {
        tau = mdate() - p_synchro->decoding_start;

        /* If duration too high, something happened (pause ?), so don't
         * take it into account. */
        if( tau < 3 * p_synchro->p_tau[i_coding_type]
372 373
             || ( !p_synchro->pi_meaningful[i_coding_type]
                   && tau < MAX_VALID_TAU ) )
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
        {
            /* Mean with average tau, to ensure stability. */
            p_synchro->p_tau[i_coding_type] =
                (p_synchro->pi_meaningful[i_coding_type]
                 * p_synchro->p_tau[i_coding_type] + tau)
                / (p_synchro->pi_meaningful[i_coding_type] + 1);
            if( p_synchro->pi_meaningful[i_coding_type] < MAX_PIC_AVERAGE )
            {
                p_synchro->pi_meaningful[i_coding_type]++;
            }
        }
    }
}

/*****************************************************************************
389
 * decoder_SynchroDate : When an image has been decoded, ask for its date
390
 *****************************************************************************/
391
mtime_t decoder_SynchroDate( decoder_synchro_t * p_synchro )
392 393 394 395 396 397
{
    /* No need to lock, since PTS are only used by the video parser. */
    return p_synchro->current_pts;
}

/*****************************************************************************
398
 * decoder_SynchroNewPicture: Update stream structure and PTS
399
 *****************************************************************************/
400
void decoder_SynchroNewPicture( decoder_synchro_t * p_synchro, int i_coding_type,
401 402
                                int i_repeat_field, mtime_t next_pts,
                                mtime_t next_dts, bool b_low_delay )
403
{
404
    mtime_t         period = 1000000 * 1001 / p_synchro->i_frame_rate;
405
#if 0
Clément Stenac's avatar
Clément Stenac committed
406
    mtime_t         now = mdate();
407 408 409 410 411 412 413 414
#endif

    switch( i_coding_type )
    {
    case I_CODING_TYPE:
        if( p_synchro->i_eta_p
             && p_synchro->i_eta_p != p_synchro->i_n_p )
        {
415
#if 0
416
            if( !p_synchro->b_quiet )
417
                msg_Dbg( p_synchro->p_dec,
418 419
                         "stream periodicity changed from P[%d] to P[%d]",
                         p_synchro->i_n_p, p_synchro->i_eta_p );
420
#endif
421 422 423
            p_synchro->i_n_p = p_synchro->i_eta_p;
        }
        p_synchro->i_eta_p = p_synchro->i_eta_b = 0;
424 425 426 427 428
        p_synchro->i_trash_nb_ref = 0;
        if( p_synchro->i_nb_ref < 2 )
            p_synchro->i_dec_nb_ref = p_synchro->i_nb_ref + 1;
        else
            p_synchro->i_dec_nb_ref = p_synchro->i_nb_ref;
429 430

#if 0
431
        if( !p_synchro->b_quiet )
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
432 433
            msg_Dbg( p_synchro->p_dec, "I(%"PRId64") P(%"PRId64")[%d] B(%"PRId64")"
                  "[%d] YUV(%"PRId64") : trashed %d:%d/%d",
434 435 436 437 438 439 440 441 442 443
                  p_synchro->p_tau[I_CODING_TYPE],
                  p_synchro->p_tau[P_CODING_TYPE],
                  p_synchro->i_n_p,
                  p_synchro->p_tau[B_CODING_TYPE],
                  p_synchro->i_n_b,
                  p_synchro->i_render_time,
                  p_synchro->i_not_chosen_pic,
                  p_synchro->i_trashed_pic -
                  p_synchro->i_not_chosen_pic,
                  p_synchro->i_pic );
444 445 446
        p_synchro->i_trashed_pic = p_synchro->i_not_chosen_pic
            = p_synchro->i_pic = 0;
#else
447
        if( p_synchro->i_pic >= 100 )
448
        {
449
            if( !p_synchro->b_quiet && p_synchro->i_trashed_pic != 0 )
450
                msg_Dbg( p_synchro->p_dec, "decoded %d/%d pictures",
451 452 453
                         p_synchro->i_pic
                           - p_synchro->i_trashed_pic,
                         p_synchro->i_pic );
454 455 456 457 458 459 460 461 462 463 464
            p_synchro->i_trashed_pic = p_synchro->i_not_chosen_pic
                = p_synchro->i_pic = 0;
        }
#endif
        break;

    case P_CODING_TYPE:
        p_synchro->i_eta_p++;
        if( p_synchro->i_eta_b
             && p_synchro->i_eta_b != p_synchro->i_n_b )
        {
465
#if 0
466
            if( !p_synchro->b_quiet )
467
                msg_Dbg( p_synchro->p_dec,
468 469
                         "stream periodicity changed from B[%d] to B[%d]",
                         p_synchro->i_n_b, p_synchro->i_eta_b );
470
#endif
471 472 473
            p_synchro->i_n_b = p_synchro->i_eta_b;
        }
        p_synchro->i_eta_b = 0;
474 475
        p_synchro->i_dec_nb_ref = 2;
        p_synchro->i_trash_nb_ref = 0;
476
        break;
477

478 479
    case B_CODING_TYPE:
        p_synchro->i_eta_b++;
480 481
        p_synchro->i_dec_nb_ref = p_synchro->i_trash_nb_ref
            = p_synchro->i_nb_ref;
482 483 484 485 486
        break;
    }

    p_synchro->current_pts += p_synchro->i_current_period
                                        * (period >> 1);
Clément Stenac's avatar
Clément Stenac committed
487

488
#define PTS_THRESHOLD   (period >> 2)
489
    if( i_coding_type == B_CODING_TYPE || b_low_delay )
490 491 492 493 494 495 496 497
    {
        /* A video frame can be displayed 1, 2 or 3 times, according to
         * repeat_first_field, top_field_first, progressive_sequence and
         * progressive_frame. */
        p_synchro->i_current_period = i_repeat_field;

        if( next_pts )
        {
498
            if( (next_pts - p_synchro->current_pts
499
                    > PTS_THRESHOLD
500 501
                  || p_synchro->current_pts - next_pts
                    > PTS_THRESHOLD) && !p_synchro->b_quiet )
502
            {
503
                msg_Warn( p_synchro->p_dec, "decoder synchro warning: pts != "
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
504
                          "current_date (%"PRId64")",
505 506 507 508 509 510 511 512 513 514 515 516 517
                          p_synchro->current_pts
                              - next_pts );
            }
            p_synchro->current_pts = next_pts;
        }
    }
    else
    {
        p_synchro->i_current_period = p_synchro->i_backward_period;
        p_synchro->i_backward_period = i_repeat_field;

        if( p_synchro->backward_pts )
        {
Clément Stenac's avatar
Clément Stenac committed
518
            if( next_dts &&
519 520
                (next_dts - p_synchro->backward_pts
                    > PTS_THRESHOLD
521 522
                  || p_synchro->backward_pts - next_dts
                    > PTS_THRESHOLD) && !p_synchro->b_quiet )
523
            {
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
524
                msg_Warn( p_synchro->p_dec, "backward_pts != dts (%"PRId64")",
525 526 527
                           next_dts
                               - p_synchro->backward_pts );
            }
528
            if( (p_synchro->backward_pts - p_synchro->current_pts
529
                    > PTS_THRESHOLD
530 531
                  || p_synchro->current_pts - p_synchro->backward_pts
                    > PTS_THRESHOLD) && !p_synchro->b_quiet )
532
            {
533
                msg_Warn( p_synchro->p_dec,
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
534
                          "backward_pts != current_pts (%"PRId64")",
535 536 537 538 539 540 541 542
                          p_synchro->current_pts
                              - p_synchro->backward_pts );
            }
            p_synchro->current_pts = p_synchro->backward_pts;
            p_synchro->backward_pts = 0;
        }
        else if( next_dts )
        {
543
            if( (next_dts - p_synchro->current_pts
544
                    > PTS_THRESHOLD
545 546
                  || p_synchro->current_pts - next_dts
                    > PTS_THRESHOLD) && !p_synchro->b_quiet )
547
            {
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
548
                msg_Warn( p_synchro->p_dec, "dts != current_pts (%"PRId64")",
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
                          p_synchro->current_pts
                              - next_dts );
            }
            /* By definition of a DTS. */
            p_synchro->current_pts = next_dts;
            next_dts = 0;
        }

        if( next_pts )
        {
            /* Store the PTS for the next time we have to date an I picture. */
            p_synchro->backward_pts = next_pts;
            next_pts = 0;
        }
    }
#undef PTS_THRESHOLD

#if 0
    /* Removed for incompatibility with slow motion */
    if( p_synchro->current_pts + DEFAULT_PTS_DELAY < now )
    {
        /* We cannot be _that_ late, something must have happened, reinit
         * the dates. */
572
        if( !p_synchro->b_quiet )
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
573
            msg_Warn( p_synchro->p_dec, "PTS << now (%"PRId64"), resetting",
574
                      now - p_synchro->current_pts - DEFAULT_PTS_DELAY );
575 576 577 578 579 580 581 582 583 584 585 586
        p_synchro->current_pts = now + DEFAULT_PTS_DELAY;
    }
    if( p_synchro->backward_pts
         && p_synchro->backward_pts + DEFAULT_PTS_DELAY < now )
    {
        /* The same. */
        p_synchro->backward_pts = 0;
    }
#endif

    p_synchro->i_pic++;
}