git.sesse.net Git - vlc/blob - src/video_parser/vpar_synchro.c

   1 /*****************************************************************************
   2  * vpar_synchro.c : frame dropping routines
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  *
   6  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   7  *          Samuel Hocevar <sam@via.ecp.fr>
   8  *          Jean-Marc Dressler <polux@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*
  26  * DISCUSSION : How to Write an efficient Frame-Dropping Algorithm
  27  * ==========
  28  *
  29  * This implementation is based on mathematical and statistical
  30  * developments. Older implementations used an enslavement, considering
  31  * that if we're late when reading an I picture, we will decode one frame
  32  * less. It had a tendancy to derive, and wasn't responsive enough, which
  33  * would have caused trouble with the stream control stuff.
  34  *
  35  * 1. Structure of a picture stream
  36  *    =============================
  37  * Between 2 I's, we have for instance :
  38  *    I   B   P   B   P   B   P   B   P   B   P   B   I
  39  *    t0  t1  t2  t3  t4  t5  t6  t7  t8  t9  t10 t11 t12
  40  * Please bear in mind that B's and IP's will be inverted when displaying
  41  * (decoding order != presentation order). Thus, t1 < t0.
  42  *
  43  * 2. Definitions
  44  *    ===========
  45  * t[0..12]     : Presentation timestamps of pictures 0..12.
  46  * t            : Current timestamp, at the moment of the decoding.
  47  * T            : Picture period, T = 1/frame_rate.
  48  * tau[I,P,B]   : Mean time to decode an [I,P,B] picture.
  49  * tauYUV       : Mean time to render a picture (given by the video_output).
  50  * tau´[I,P,B] = 2 * tau[I,P,B] + tauYUV
  51  *              : Mean time + typical difference (estimated to tau/2, that
  52  *                needs to be confirmed) + render time.
  53  * DELTA        : A given error margin.
  54  *
  55  * 3. General considerations
  56  *    ======================
  57  * We define to types of machines :
  58  *      2T > tauP  : machines capable of decoding all P pictures
  59  *      14T > tauI : machines capable of decoding all I pictures
  60  *
  61  * 4. Decoding of an I picture
  62  *    ========================
  63  * On fast machines, we decode all I's.
  64  * Otherwise :
  65  * We can decode an I picture if we simply have enough time to decode it
  66  * before displaying :
  67  *      t0 - t > tau´I + DELTA
  68  *
  69  * 4. Decoding of a P picture
  70  *    =======================
  71  * On fast machines, we decode all P's.
  72  * Otherwise :
  73  * First criterion : have time to decode it.
  74  *      t2 - t > tau´P + DELTA
  75  *
  76  * Second criterion : it shouldn't prevent us from displaying the forthcoming
  77  * I picture, which is more important.
  78  *      t12 - t > tau´P + tau´I + DELTA
  79  *
  80  * 5. Decoding of a B picture
  81  *    =======================
  82  * First criterion : have time to decode it.
  83  *      t1 - t > tau´B + DELTA
  84  *
  85  * Second criterion : it shouldn't prevent us from displaying the forthcoming
  86  * P picture, which is more important.
  87  *      t4 - t > tau´B + tau´P + DELTA
  88  *
  89  * I hope you will have a pleasant flight and do not forget your life
  90  * jacket.
  91  *                                                  --Meuuh (2000-11-09)
  92  */
  93
  94 /*****************************************************************************
  95  * Preamble
  96  *****************************************************************************/
  97 #include "defs.h"
  98
  99 #include <stdlib.h>                                                /* free() */
 100 #include <sys/types.h>                        /* on BSD, uio.h needs types.h */
 101 #include <sys/uio.h>                                            /* "input.h" */
 102
 103 #include "config.h"
 104 #include "common.h"
 105 #include "threads.h"
 106 #include "mtime.h"
 107 #include "plugins.h"
 108
 109 #include "intf_msg.h"
 110
 111 #include "input.h"
 112 #include "decoder_fifo.h"
 113 #include "video.h"
 114 #include "video_output.h"
 115
 116 #include "vdec_idct.h"
 117 #include "video_decoder.h"
 118 #include "vdec_motion.h"
 119
 120 #include "vpar_blocks.h"
 121 #include "vpar_headers.h"
 122 #include "vpar_synchro.h"
 123 #include "video_parser.h"
 124
 125 #include "main.h"
 126
 127 /*
 128  * Local prototypes
 129  */
 130 static int  SynchroType( void );
 131 static void SynchroNewPicture( vpar_thread_t * p_vpar, int i_coding_type );
 132
 133 /* Error margins */
 134 #define DELTA                   (int)(0.060*CLOCK_FREQ)
 135
 136 #define DEFAULT_NB_P            5
 137 #define DEFAULT_NB_B            1
 138
 139 /*****************************************************************************
 140  * vpar_SynchroInit : You know what ?
 141  *****************************************************************************/
 142 void vpar_SynchroInit( vpar_thread_t * p_vpar )
 143 {
 144     p_vpar->synchro.i_type = SynchroType();
 145     p_vpar->synchro.i_start = p_vpar->synchro.i_end = 0;
 146     vlc_mutex_init( &p_vpar->synchro.fifo_lock );
 147
 148     /* We use a fake stream pattern, which is often right. */
 149     p_vpar->synchro.i_n_p = p_vpar->synchro.i_eta_p = DEFAULT_NB_P;
 150     p_vpar->synchro.i_n_b = p_vpar->synchro.i_eta_b = DEFAULT_NB_B;
 151     memset( p_vpar->synchro.p_tau, 0, 4 * sizeof(mtime_t) );
 152     memset( p_vpar->synchro.pi_meaningful, 0, 4 * sizeof(unsigned int) );
 153     p_vpar->synchro.b_dropped_last = 0;
 154     p_vpar->synchro.current_pts = mdate() + INPUT_PTS_DELAY;
 155     p_vpar->synchro.backward_pts = 0;
 156 }
 157
 158 /*****************************************************************************
 159  * vpar_SynchroChoose : Decide whether we will decode a picture or not
 160  *****************************************************************************/
 161 boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type,
 162                               int i_structure )
 163 {
 164     /* For clarity reasons, we separated the special synchros code from the
 165      * mathematical synchro */
 166
 167     if( p_vpar->synchro.i_type != VPAR_SYNCHRO_DEFAULT )
 168     {
 169         switch( i_coding_type )
 170         {
 171         case I_CODING_TYPE:
 172             /* I, IP, IP+, IPB */
 173             if( p_vpar->synchro.i_type == VPAR_SYNCHRO_Iplus )
 174             {
 175                 p_vpar->synchro.b_dropped_last = 1;
 176             }
 177             return( 1 );
 178
 179         case P_CODING_TYPE:
 180             if( p_vpar->synchro.i_type == VPAR_SYNCHRO_I ) /* I */
 181             {
 182                 return( 0 );
 183             }
 184
 185             if( p_vpar->synchro.i_type == VPAR_SYNCHRO_Iplus ) /* I+ */
 186             {
 187                 if( p_vpar->synchro.b_dropped_last )
 188                 {
 189                     p_vpar->synchro.b_dropped_last = 0;
 190                     return( 1 );
 191                 }
 192                 else
 193                 {
 194                     return( 0 );
 195                 }
 196             }
 197
 198             return( 1 ); /* IP, IP+, IPB */
 199
 200         case B_CODING_TYPE:
 201             if( p_vpar->synchro.i_type <= VPAR_SYNCHRO_IP ) /* I, IP */
 202             {
 203                 return( 0 );
 204             }
 205             else if( p_vpar->synchro.i_type == VPAR_SYNCHRO_IPB ) /* IPB */
 206             {
 207                 return( 1 );
 208             }
 209
 210             p_vpar->synchro.b_dropped_last ^= 1; /* IP+ */
 211             return( !p_vpar->synchro.b_dropped_last );
 212         }
 213         return( 0 ); /* never reached but gcc yells at me */
 214     }
 215     else
 216     {
 217 #define TAU_PRIME( coding_type )    (p_vpar->synchro.p_tau[(coding_type)] \
 218                                  + (p_vpar->synchro.p_tau[(coding_type)] >> 1) \
 219                                             + tau_yuv)
 220 #define S                           p_vpar->synchro
 221         /* VPAR_SYNCHRO_DEFAULT */
 222         mtime_t         now, pts, period, tau_yuv;
 223         boolean_t       b_decode = 0;
 224
 225         now = mdate();
 226         period = 1000000 / (p_vpar->sequence.i_frame_rate) * 1001;
 227
 228         vlc_mutex_lock( &p_vpar->p_vout->change_lock );
 229         tau_yuv = p_vpar->p_vout->render_time;
 230         vlc_mutex_unlock( &p_vpar->p_vout->change_lock );
 231
 232         vlc_mutex_lock( &p_vpar->synchro.fifo_lock );
 233
 234         switch( i_coding_type )
 235         {
 236         case I_CODING_TYPE:
 237             /* Stream structure changes */
 238             if( S.i_n_p )
 239                 S.i_n_p = S.i_eta_p;
 240
 241             if( S.backward_pts )
 242             {
 243                 pts = S.backward_pts;
 244             }
 245             else
 246             {
 247                 pts = S.current_pts + period * S.i_n_b;
 248             }
 249
 250             b_decode = ( (1 + S.i_n_p * (S.i_n_b + 1)) * period >
 251                            S.p_tau[I_CODING_TYPE] ) ||
 252                        ( (pts - now) > (TAU_PRIME(I_CODING_TYPE) + DELTA) );
 253             if( !b_decode )
 254                 intf_WarnMsg( 3, "vpar synchro warning: trashing I\n" );
 255             break;
 256
 257         case P_CODING_TYPE:
 258             /* Stream structure changes */
 259             if( S.i_n_b )
 260                 S.i_n_b = S.i_eta_b;
 261             if( S.i_eta_p + 1 > S.i_n_p )
 262                 S.i_n_p++;
 263
 264             if( S.backward_pts )
 265             {
 266                 pts = S.backward_pts;
 267             }
 268             else
 269             {
 270                 pts = S.current_pts + period * S.i_n_b;
 271             }
 272
 273             if( (S.i_n_b + 1) * period > S.p_tau[P_CODING_TYPE] )
 274             {
 275                 /* Security in case we're _really_ late */
 276                 b_decode = (pts - now > 0);
 277             }
 278             else
 279             {
 280                 b_decode = (pts - now) > (TAU_PRIME(P_CODING_TYPE) + DELTA);
 281                 /* next I */
 282                 b_decode &= (pts - now
 283                               + period
 284                           * ( (S.i_n_p - S.i_eta_p - 1) * (1 + S.i_n_b) - 1 ))
 285                             > (TAU_PRIME(P_CODING_TYPE)
 286                                 + TAU_PRIME(I_CODING_TYPE) + DELTA);
 287             }
 288             break;
 289
 290         case B_CODING_TYPE:
 291             /* Stream structure changes */
 292             if( S.i_eta_b + 1 > S.i_n_b )
 293                 S.i_n_b++;
 294
 295             pts = S.current_pts;
 296
 297             if( (S.i_n_b + 1) * period > S.p_tau[P_CODING_TYPE] )
 298             {
 299                 b_decode = (pts - now) > (TAU_PRIME(B_CODING_TYPE) + DELTA);
 300
 301                 /* Remember that S.i_eta_b is for the moment only eta_b - 1. */
 302                 if( S.i_eta_p != S.i_n_p ) /* next P */
 303                 {
 304                     b_decode &= (pts - now
 305                                  + period
 306                                  * ( 2 * S.i_n_b - S.i_eta_b - 1))
 307                                    > (TAU_PRIME(B_CODING_TYPE)
 308                                        + TAU_PRIME(P_CODING_TYPE) + DELTA);
 309                 }
 310                 else /* next I */
 311                 {
 312                     b_decode &= (pts - now
 313                                  + period
 314                                  * ( 2 * S.i_n_b - S.i_eta_b - 1))
 315                                    > (TAU_PRIME(B_CODING_TYPE)
 316                                        + TAU_PRIME(I_CODING_TYPE) + DELTA);
 317                 }
 318             }
 319             else
 320             {
 321                 b_decode = 0;
 322             }
 323         }
 324
 325         vlc_mutex_unlock( &p_vpar->synchro.fifo_lock );
 326         return( b_decode );
 327 #undef S
 328 #undef TAU_PRIME
 329     }
 330 }
 331
 332 /*****************************************************************************
 333  * vpar_SynchroTrash : Update timers when we trash a picture
 334  *****************************************************************************/
 335 void vpar_SynchroTrash( vpar_thread_t * p_vpar, int i_coding_type,
 336                         int i_structure )
 337 {
 338     SynchroNewPicture( p_vpar, i_coding_type );
 339 #ifdef STATS
 340     p_vpar->synchro.i_trashed_pic++;
 341 #endif
 342 }
 343
 344 /*****************************************************************************
 345  * vpar_SynchroDecode : Update timers when we decide to decode a picture
 346  *****************************************************************************/
 347 void vpar_SynchroDecode( vpar_thread_t * p_vpar, int i_coding_type,
 348                          int i_structure )
 349 {
 350     vlc_mutex_lock( &p_vpar->synchro.fifo_lock );
 351
 352     if( ((p_vpar->synchro.i_end + 1 - p_vpar->synchro.i_start)
 353             % MAX_DECODING_PIC) )
 354     {
 355         p_vpar->synchro.p_date_fifo[p_vpar->synchro.i_end] = mdate();
 356         p_vpar->synchro.pi_coding_types[p_vpar->synchro.i_end] = i_coding_type;
 357
 358         FIFO_INCREMENT( i_end );
 359     }
 360     else
 361     {
 362         /* FIFO full, panic() */
 363         intf_ErrMsg("vpar error: synchro fifo full, estimations will be biased\n");
 364     }
 365     vlc_mutex_unlock( &p_vpar->synchro.fifo_lock );
 366
 367     SynchroNewPicture( p_vpar, i_coding_type );
 368 }
 369
 370 /*****************************************************************************
 371  * vpar_SynchroEnd : Called when the image is totally decoded
 372  *****************************************************************************/
 373 void vpar_SynchroEnd( vpar_thread_t * p_vpar )
 374 {
 375     mtime_t     tau;
 376     int         i_coding_type;
 377
 378     vlc_mutex_lock( &p_vpar->synchro.fifo_lock );
 379
 380     tau = mdate() - p_vpar->synchro.p_date_fifo[p_vpar->synchro.i_start];
 381     i_coding_type = p_vpar->synchro.pi_coding_types[p_vpar->synchro.i_start];
 382
 383     /* Mean with average tau, to ensure stability. */
 384     p_vpar->synchro.p_tau[i_coding_type] =
 385         (p_vpar->synchro.pi_meaningful[i_coding_type]
 386           * p_vpar->synchro.p_tau[i_coding_type] + tau)
 387         / (p_vpar->synchro.pi_meaningful[i_coding_type] + 1);
 388     if( p_vpar->synchro.pi_meaningful[i_coding_type] < MAX_PIC_AVERAGE )
 389     {
 390         p_vpar->synchro.pi_meaningful[i_coding_type]++;
 391     }
 392
 393     FIFO_INCREMENT( i_start );
 394
 395     vlc_mutex_unlock( &p_vpar->synchro.fifo_lock );
 396 }
 397
 398 /*****************************************************************************
 399  * vpar_SynchroDate : When an image has been decoded, ask for its date
 400  *****************************************************************************/
 401 mtime_t vpar_SynchroDate( vpar_thread_t * p_vpar )
 402 {
 403     /* No need to lock, since PTS are only used by the video parser. */
 404     return( p_vpar->synchro.current_pts );
 405 }
 406
 407 /*****************************************************************************
 408  * SynchroType: Get the user's synchro type
 409  *****************************************************************************
 410  * This function is called at initialization.
 411  *****************************************************************************/
 412 static int SynchroType( void )
 413 {
 414     char * psz_synchro = main_GetPszVariable( VPAR_SYNCHRO_VAR, NULL );
 415
 416     if( psz_synchro == NULL )
 417     {
 418         return VPAR_SYNCHRO_DEFAULT;
 419     }
 420
 421     switch( *psz_synchro++ )
 422     {
 423       case 'i':
 424       case 'I':
 425         switch( *psz_synchro++ )
 426         {
 427           case '\0':
 428             return VPAR_SYNCHRO_I;
 429
 430           case '+':
 431             if( *psz_synchro ) return 0;
 432             return VPAR_SYNCHRO_Iplus;
 433
 434           case 'p':
 435           case 'P':
 436             switch( *psz_synchro++ )
 437             {
 438               case '\0':
 439                 return VPAR_SYNCHRO_IP;
 440
 441               case '+':
 442                 if( *psz_synchro ) return 0;
 443                 return VPAR_SYNCHRO_IPplus;
 444
 445               case 'b':
 446               case 'B':
 447                 if( *psz_synchro ) return 0;
 448                 return VPAR_SYNCHRO_IPB;
 449
 450               default:
 451                 return VPAR_SYNCHRO_DEFAULT;
 452
 453             }
 454
 455           default:
 456             return VPAR_SYNCHRO_DEFAULT;
 457         }
 458     }
 459
 460     return VPAR_SYNCHRO_DEFAULT;
 461 }
 462
 463 /*****************************************************************************
 464  * SynchroNewPicture: Update stream structure and PTS
 465  *****************************************************************************/
 466 static void SynchroNewPicture( vpar_thread_t * p_vpar, int i_coding_type )
 467 {
 468     pes_packet_t * p_pes;
 469
 470     switch( i_coding_type )
 471     {
 472     case I_CODING_TYPE:
 473         p_vpar->synchro.i_eta_p = p_vpar->synchro.i_eta_b = 0;
 474 #ifdef STATS
 475         intf_Msg( "vpar synchro stats: I(%lld) P(%lld)[%d] B(%lld)[%d] YUV(%lld) : %d/%d\n",
 476                   p_vpar->synchro.p_tau[I_CODING_TYPE],
 477                   p_vpar->synchro.p_tau[P_CODING_TYPE],
 478                   p_vpar->synchro.i_n_p,
 479                   p_vpar->synchro.p_tau[B_CODING_TYPE],
 480                   p_vpar->synchro.i_n_b,
 481                   p_vpar->p_vout->render_time,
 482                   1 + p_vpar->synchro.i_n_p * (1 + p_vpar->synchro.i_n_b) -
 483                   p_vpar->synchro.i_trashed_pic,
 484                   1 + p_vpar->synchro.i_n_p * (1 + p_vpar->synchro.i_n_b) );
 485         p_vpar->synchro.i_trashed_pic = 0;
 486 #endif
 487         break;
 488     case P_CODING_TYPE:
 489         p_vpar->synchro.i_eta_b = 0;
 490         p_vpar->synchro.i_eta_p++;
 491         break;
 492     case B_CODING_TYPE:
 493         p_vpar->synchro.i_eta_b++;
 494         break;
 495     }
 496
 497     p_pes = DECODER_FIFO_START( *p_vpar->bit_stream.p_decoder_fifo );
 498
 499     if( i_coding_type == B_CODING_TYPE )
 500     {
 501         if( p_pes->b_has_pts )
 502         {
 503             if( p_pes->i_pts < p_vpar->synchro.current_pts )
 504             {
 505                 intf_WarnMsg( 2,
 506                         "vpar synchro warning: pts_date < current_date\n" );
 507             }
 508             p_vpar->synchro.current_pts = p_pes->i_pts;
 509             p_pes->b_has_pts = 0;
 510         }
 511         else
 512         {
 513             p_vpar->synchro.current_pts += 1000000 / (p_vpar->sequence.i_frame_rate) * 1001;
 514         }
 515     }
 516     else
 517     {
 518         if( p_vpar->synchro.backward_pts == 0 )
 519         {
 520             p_vpar->synchro.current_pts += 1000000 / (p_vpar->sequence.i_frame_rate) * 1001;
 521         }
 522         else
 523         {
 524             if( p_vpar->synchro.backward_pts < p_vpar->synchro.current_pts )
 525             {
 526                 intf_WarnMsg( 2,
 527                         "vpar warning: backward_date < current_date\n" );
 528             }
 529             p_vpar->synchro.current_pts = p_vpar->synchro.backward_pts;
 530             p_vpar->synchro.backward_pts = 0;
 531         }
 532
 533         if( p_pes->b_has_pts )
 534         {
 535             /* Store the PTS for the next time we have to date an I picture. */
 536             p_vpar->synchro.backward_pts = p_pes->i_pts;
 537             p_pes->b_has_pts = 0;
 538         }
 539     }
 540 }