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

   1 /*****************************************************************************
   2  * video_parser.c : video parser thread
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  *
   6  * Authors:
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /* FIXME: passer en terminate/destroy avec les signaux supplémentaires ?? */
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include "defs.h"
  29
  30 #include <stdlib.h>                                      /* malloc(), free() */
  31 #include <unistd.h>                                              /* getpid() */
  32 #include <sys/types.h>                        /* on BSD, uio.h needs types.h */
  33 #include <sys/uio.h>                                            /* "input.h" */
  34
  35 #include "config.h"
  36 #include "common.h"
  37 #include "threads.h"
  38 #include "mtime.h"
  39 #include "plugins.h"
  40
  41 #include "intf_msg.h"
  42 #include "debug.h"                 /* XXX?? temporaire, requis par netlist.h */
  43
  44 #include "input.h"
  45 #include "input_netlist.h"
  46 #include "decoder_fifo.h"
  47 #include "video.h"
  48 #include "video_output.h"
  49
  50 #include "vdec_idct.h"
  51 #include "video_decoder.h"
  52 #include "vdec_motion.h"
  53
  54 #include "vpar_blocks.h"
  55 #include "vpar_headers.h"
  56 #include "vpar_synchro.h"
  57 #include "video_parser.h"
  58 #include "video_fifo.h"
  59
  60 /*
  61  * Local prototypes
  62  */
  63 //static int      CheckConfiguration  ( video_cfg_t *p_cfg );
  64 static int      InitThread          ( vpar_thread_t *p_vpar );
  65 static void     RunThread           ( vpar_thread_t *p_vpar );
  66 static void     ErrorThread         ( vpar_thread_t *p_vpar );
  67 static void     EndThread           ( vpar_thread_t *p_vpar );
  68 static int      SynchroType         ( );
  69
  70 /*****************************************************************************
  71  * vpar_CreateThread: create a generic parser thread
  72  *****************************************************************************
  73  * This function creates a new video parser thread, and returns a pointer
  74  * to its description. On error, it returns NULL.
  75  * Following configuration properties are used:
  76  * XXX??
  77  *****************************************************************************/
  78 #include "main.h"
  79 #include "interface.h"
  80 extern main_t* p_main;
  81 vpar_thread_t * vpar_CreateThread( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*,
  82                                    vout_thread_t *p_vout, int *pi_status */ )
  83 {
  84     vpar_thread_t *     p_vpar;
  85
  86     intf_DbgMsg( "vpar debug: creating video parser thread\n" );
  87
  88     /* Allocate the memory needed to store the thread's structure */
  89     if ( (p_vpar = (vpar_thread_t *)malloc( sizeof(vpar_thread_t) )) == NULL )
  90     {
  91         intf_ErrMsg( "vpar error: not enough memory "
  92                      "for vpar_CreateThread() to create the new thread\n");
  93         return( NULL );
  94     }
  95
  96     /*
  97      * Initialize the thread properties
  98      */
  99     p_vpar->b_die = 0;
 100     p_vpar->b_error = 0;
 101
 102     /*
 103      * Initialize the input properties
 104      */
 105     /* Initialize the decoder fifo's data lock and conditional variable
 106      * and set its buffer as empty */
 107     vlc_mutex_init( &p_vpar->fifo.data_lock );
 108     vlc_cond_init( &p_vpar->fifo.data_wait );
 109     p_vpar->fifo.i_start = 0;
 110     p_vpar->fifo.i_end = 0;
 111     /* Initialize the bit stream structure */
 112     p_vpar->bit_stream.p_input = p_input;
 113     p_vpar->bit_stream.p_decoder_fifo = &p_vpar->fifo;
 114     p_vpar->bit_stream.fifo.buffer = 0;
 115     p_vpar->bit_stream.fifo.i_available = 0;
 116
 117     /* FIXME !!!!?? */
 118     p_vpar->p_vout = p_main->p_intf->p_vout;
 119
 120     /* Spawn the video parser thread */
 121     if ( vlc_thread_create( &p_vpar->thread_id, "video parser",
 122                             (vlc_thread_func_t)RunThread, (void *)p_vpar ) )
 123     {
 124         intf_ErrMsg("vpar error: can't spawn video parser thread\n");
 125         free( p_vpar );
 126         return( NULL );
 127     }
 128
 129     intf_DbgMsg("vpar debug: video parser thread (%p) created\n", p_vpar);
 130     return( p_vpar );
 131 }
 132
 133 /*****************************************************************************
 134  * vpar_DestroyThread: destroy a generic parser thread
 135  *****************************************************************************
 136  * Destroy a terminated thread. This function will return 0 if the thread could
 137  * be destroyed, and non 0 else. The last case probably means that the thread
 138  * was still active, and another try may succeed.
 139  *****************************************************************************/
 140 void vpar_DestroyThread( vpar_thread_t *p_vpar /*, int *pi_status */ )
 141 {
 142     intf_DbgMsg( "vpar debug: requesting termination of "
 143                  "video parser thread %p\n", p_vpar);
 144
 145     /* Ask thread to kill itself */
 146     p_vpar->b_die = 1;
 147     /* Make sure the parser thread leaves the GetByte() function */
 148     vlc_mutex_lock( &(p_vpar->fifo.data_lock) );
 149     vlc_cond_signal( &(p_vpar->fifo.data_wait) );
 150     vlc_mutex_unlock( &(p_vpar->fifo.data_lock) );
 151
 152     /* Waiting for the parser thread to exit */
 153     /* Remove this as soon as the "status" flag is implemented */
 154     vlc_thread_join( p_vpar->thread_id );
 155 }
 156
 157 /* following functions are local */
 158
 159 /*****************************************************************************
 160  * CheckConfiguration: check vpar_CreateThread() configuration
 161  *****************************************************************************
 162  * Set default parameters where required. In DEBUG mode, check if configuration
 163  * is valid.
 164  *****************************************************************************/
 165 #if 0
 166 static int CheckConfiguration( video_cfg_t *p_cfg )
 167 {
 168     /* XXX?? */
 169
 170     return( 0 );
 171 }
 172 #endif
 173
 174 /*****************************************************************************
 175  * InitThread: initialize vpar output thread
 176  *****************************************************************************
 177  * This function is called from RunThread and performs the second step of the
 178  * initialization. It returns 0 on success. Note that the thread's flag are not
 179  * modified inside this function.
 180  *****************************************************************************/
 181 static int InitThread( vpar_thread_t *p_vpar )
 182 {
 183 #ifdef VDEC_SMP
 184     int i_dummy;
 185 #endif
 186
 187     intf_DbgMsg("vpar debug: initializing video parser thread %p\n", p_vpar);
 188
 189     /* Our first job is to initialize the bit stream structure with the
 190      * beginning of the input stream */
 191     vlc_mutex_lock( &p_vpar->fifo.data_lock );
 192     while ( DECODER_FIFO_ISEMPTY(p_vpar->fifo) )
 193     {
 194         if ( p_vpar->b_die )
 195         {
 196             vlc_mutex_unlock( &p_vpar->fifo.data_lock );
 197             return( 1 );
 198         }
 199         vlc_cond_wait( &p_vpar->fifo.data_wait, &p_vpar->fifo.data_lock );
 200     }
 201     p_vpar->bit_stream.p_ts = DECODER_FIFO_START( p_vpar->fifo )->p_first_ts;
 202     p_vpar->bit_stream.p_byte = p_vpar->bit_stream.p_ts->buffer
 203                                 + p_vpar->bit_stream.p_ts->i_payload_start;
 204     p_vpar->bit_stream.p_end = p_vpar->bit_stream.p_ts->buffer
 205                                + p_vpar->bit_stream.p_ts->i_payload_end;
 206     vlc_mutex_unlock( &p_vpar->fifo.data_lock );
 207
 208     /* Initialize parsing data */
 209     p_vpar->sequence.p_forward = NULL;
 210     p_vpar->sequence.p_backward = NULL;
 211     p_vpar->sequence.intra_quant.b_allocated = 0;
 212     p_vpar->sequence.nonintra_quant.b_allocated = 0;
 213     p_vpar->sequence.chroma_intra_quant.b_allocated = 0;
 214     p_vpar->sequence.chroma_nonintra_quant.b_allocated = 0;
 215
 216     /* Initialize copyright information */
 217     p_vpar->sequence.b_copyright_flag = 0;
 218     p_vpar->sequence.b_original = 0;
 219     p_vpar->sequence.i_copyright_id = 0;
 220     p_vpar->sequence.i_copyright_nb = 0;
 221
 222     p_vpar->picture.p_picture = NULL;
 223     p_vpar->picture.i_current_structure = 0;
 224
 225     /* Initialize other properties */
 226 #ifdef STATS
 227     p_vpar->c_loops = 0;
 228     p_vpar->c_idle_loops = 0;
 229     p_vpar->c_pictures = 0;
 230     p_vpar->c_i_pictures = 0;
 231     p_vpar->c_p_pictures = 0;
 232     p_vpar->c_b_pictures = 0;
 233     p_vpar->c_decoded_pictures = 0;
 234     p_vpar->c_decoded_i_pictures = 0;
 235     p_vpar->c_decoded_p_pictures = 0;
 236     p_vpar->c_decoded_b_pictures = 0;
 237 #endif
 238
 239     /* Initialize video FIFO */
 240     vpar_InitFIFO( p_vpar );
 241
 242     memset( p_vpar->pp_vdec, 0, NB_VDEC*sizeof(vdec_thread_t *) );
 243
 244 #ifdef VDEC_SMP
 245     /* Spawn video_decoder threads */
 246     /* FIXME: modify the number of vdecs at runtime ?? */
 247     for( i_dummy = 0; i_dummy < NB_VDEC; i_dummy++ )
 248     {
 249         if( (p_vpar->pp_vdec[i_dummy] = vdec_CreateThread( p_vpar )) == NULL )
 250         {
 251             return( 1 );
 252         }
 253     }
 254 #else
 255     /* Fake a video_decoder thread */
 256     if( (p_vpar->pp_vdec[0] = (vdec_thread_t *)malloc(sizeof( vdec_thread_t )))
 257          == NULL || vdec_InitThread( p_vpar->pp_vdec[0] ) )
 258     {
 259         return( 1 );
 260     }
 261     p_vpar->pp_vdec[0]->b_die = 0;
 262     p_vpar->pp_vdec[0]->b_error = 0;
 263     p_vpar->pp_vdec[0]->p_vpar = p_vpar;
 264 #endif
 265
 266     /* Initialize lookup tables */
 267 #if defined(MPEG2_COMPLIANT) && !defined(VDEC_DFT)
 268     vpar_InitCrop( p_vpar );
 269 #endif
 270     vpar_InitMbAddrInc( p_vpar );
 271     vpar_InitDCTTables( p_vpar );
 272     vpar_InitPMBType( p_vpar );
 273     vpar_InitBMBType( p_vpar );
 274     vpar_InitDCTTables( p_vpar );
 275
 276     /*
 277      * Initialize the synchro properties
 278      */
 279 #ifdef SAM_SYNCHRO
 280     /* Get an possible synchro algorithm */
 281     p_vpar->synchro.i_type = SynchroType();
 282
 283     /* last seen PTS */
 284     p_vpar->synchro.i_last_pts = 0;
 285
 286     /* for i frames */
 287     p_vpar->synchro.i_last_seen_I_pts = 0;
 288     p_vpar->synchro.i_last_kept_I_pts = 0;
 289
 290     /* the fifo */
 291     p_vpar->synchro.i_start  = 0;
 292     p_vpar->synchro.i_stop   = 0;
 293
 294     /* mean decoding time - at least 200 ms for a slow machine */
 295     p_vpar->synchro.i_delay            = 200000;
 296     p_vpar->synchro.i_theorical_delay  = 40000; /* 25 fps */
 297     /* assume we can display all Is and 2 Ps */
 298     p_vpar->synchro.b_all_I = 1 << 10;
 299     p_vpar->synchro.b_all_P = 0;
 300     p_vpar->synchro.displayable_p = 2 << 10;
 301     p_vpar->synchro.b_all_B = 0;
 302     p_vpar->synchro.displayable_b = 0;
 303     p_vpar->synchro.b_dropped_last_B = 0;
 304     /* assume there were about 3 P and 6 B images between I's */
 305     p_vpar->synchro.i_P_seen = p_vpar->synchro.i_P_kept = 1 << 10;
 306     p_vpar->synchro.i_B_seen = p_vpar->synchro.i_B_kept = 1 << 10;
 307 #endif
 308
 309 #ifdef MEUUH_SYNCHRO
 310     p_vpar->synchro.kludge_level = 5;
 311     p_vpar->synchro.kludge_nbp = p_vpar->synchro.kludge_p = 5;
 312     p_vpar->synchro.kludge_nbb = p_vpar->synchro.kludge_b = 6;
 313     p_vpar->synchro.kludge_b = 0;
 314     p_vpar->synchro.kludge_prevdate = 0;
 315 #endif
 316
 317 #ifdef POLUX_SYNCHRO
 318     p_vpar->synchro.i_current_frame_date = 0;
 319     p_vpar->synchro.i_backward_frame_date = 0;
 320
 321     p_vpar->synchro.r_p_average = p_vpar->synchro.i_p_nb = 6;
 322     p_vpar->synchro.r_b_average = p_vpar->synchro.i_b_nb = 6;
 323     p_vpar->synchro.i_p_count = 0;
 324     p_vpar->synchro.i_b_count = 0;
 325     p_vpar->synchro.i_i_count = 0;
 326 #endif
 327
 328     /* Mark thread as running and return */
 329     intf_DbgMsg("vpar debug: InitThread(%p) succeeded\n", p_vpar);
 330     return( 0 );
 331 }
 332
 333 /*****************************************************************************
 334  * RunThread: generic parser thread
 335  *****************************************************************************
 336  * Video parser thread. This function only returns when the thread is
 337  * terminated.
 338  *****************************************************************************/
 339 static void RunThread( vpar_thread_t *p_vpar )
 340 {
 341     intf_DbgMsg("vpar debug: running video parser thread (%p) (pid == %i)\n", p_vpar, getpid());
 342
 343     /*
 344      * Initialize thread
 345      */
 346     p_vpar->b_error = InitThread( p_vpar );
 347
 348     p_vpar->b_run = 1;
 349
 350     /*
 351      * Main loop - it is not executed if an error occured during
 352      * initialization
 353      */
 354     while( (!p_vpar->b_die) && (!p_vpar->b_error) )
 355     {
 356         /* Find the next sequence header in the stream */
 357         p_vpar->b_error = vpar_NextSequenceHeader( p_vpar );
 358
 359 #ifdef STATS
 360         p_vpar->c_sequences++;
 361 #endif
 362
 363         while( (!p_vpar->b_die) && (!p_vpar->b_error) )
 364         {
 365             /* Parse the next sequence, group or picture header */
 366             if( vpar_ParseHeader( p_vpar ) )
 367             {
 368                 /* End of sequence */
 369                 break;
 370             };
 371         }
 372     }
 373
 374     /*
 375      * Error loop
 376      */
 377     if( p_vpar->b_error )
 378     {
 379         ErrorThread( p_vpar );
 380     }
 381
 382     p_vpar->b_run = 0;
 383
 384     /* End of thread */
 385     EndThread( p_vpar );
 386 }
 387
 388 /*****************************************************************************
 389  * ErrorThread: RunThread() error loop
 390  *****************************************************************************
 391  * This function is called when an error occured during thread main's loop. The
 392  * thread can still receive feed, but must be ready to terminate as soon as
 393  * possible.
 394  *****************************************************************************/
 395 static void ErrorThread( vpar_thread_t *p_vpar )
 396 {
 397     /* We take the lock, because we are going to read/write the start/end
 398      * indexes of the decoder fifo */
 399     vlc_mutex_lock( &p_vpar->fifo.data_lock );
 400
 401     /* Wait until a `die' order is sent */
 402     while( !p_vpar->b_die )
 403     {
 404         /* Trash all received PES packets */
 405         while( !DECODER_FIFO_ISEMPTY(p_vpar->fifo) )
 406         {
 407             input_NetlistFreePES( p_vpar->bit_stream.p_input,
 408                                   DECODER_FIFO_START(p_vpar->fifo) );
 409             DECODER_FIFO_INCSTART( p_vpar->fifo );
 410         }
 411
 412         /* Waiting for the input thread to put new PES packets in the fifo */
 413         vlc_cond_wait( &p_vpar->fifo.data_wait, &p_vpar->fifo.data_lock );
 414     }
 415
 416     /* We can release the lock before leaving */
 417     vlc_mutex_unlock( &p_vpar->fifo.data_lock );
 418 }
 419
 420 /*****************************************************************************
 421  * EndThread: thread destruction
 422  *****************************************************************************
 423  * This function is called when the thread ends after a sucessful
 424  * initialization.
 425  *****************************************************************************/
 426 static void EndThread( vpar_thread_t *p_vpar )
 427 {
 428 #ifdef VDEC_SMP
 429     int i_dummy;
 430 #endif
 431
 432     intf_DbgMsg("vpar debug: destroying video parser thread %p\n", p_vpar);
 433
 434 #ifdef DEBUG
 435     /* Check for remaining PES packets */
 436     /* XXX?? */
 437 #endif
 438
 439     /* Destroy thread structures allocated by InitThread */
 440 //    vout_DestroyStream( p_vpar->p_vout, p_vpar->i_stream );
 441     /* XXX?? */
 442
 443     /* Dispose of matrices if they have been allocated. */
 444     if( p_vpar->sequence.intra_quant.b_allocated )
 445     {
 446         free( p_vpar->sequence.intra_quant.pi_matrix );
 447     }
 448     if( p_vpar->sequence.nonintra_quant.b_allocated )
 449     {
 450         free( p_vpar->sequence.nonintra_quant.pi_matrix) ;
 451     }
 452     if( p_vpar->sequence.chroma_intra_quant.b_allocated )
 453     {
 454         free( p_vpar->sequence.chroma_intra_quant.pi_matrix );
 455     }
 456     if( p_vpar->sequence.chroma_nonintra_quant.b_allocated )
 457     {
 458         free( p_vpar->sequence.chroma_nonintra_quant.pi_matrix );
 459     }
 460
 461 #ifdef VDEC_SMP
 462     /* Destroy vdec threads */
 463     for( i_dummy = 0; i_dummy < NB_VDEC; i_dummy++ )
 464     {
 465         if( p_vpar->pp_vdec[i_dummy] != NULL )
 466             vdec_DestroyThread( p_vpar->pp_vdec[i_dummy] );
 467         else
 468             break;
 469     }
 470 #else
 471     free( p_vpar->pp_vdec[0] );
 472 #endif
 473
 474     free( p_vpar );
 475
 476     intf_DbgMsg("vpar debug: EndThread(%p)\n", p_vpar);
 477 }
 478
 479 /*****************************************************************************
 480  * SynchroType: Get the user's synchro type
 481  *****************************************************************************
 482  * This function is called at initialization.
 483  *****************************************************************************/
 484 static int SynchroType( )
 485 {
 486     char * psz_synchro = main_GetPszVariable( VPAR_SYNCHRO_VAR, NULL );
 487
 488     if( psz_synchro == NULL )
 489     {
 490         return VPAR_SYNCHRO_DEFAULT;
 491     }
 492
 493     switch( *psz_synchro++ )
 494     {
 495       case 'i':
 496       case 'I':
 497         switch( *psz_synchro++ )
 498         {
 499           case '\0':
 500             return VPAR_SYNCHRO_I;
 501
 502           case 'p':
 503           case 'P':
 504             switch( *psz_synchro++ )
 505             {
 506               case '\0':
 507                 return VPAR_SYNCHRO_IP;
 508
 509               case '+':
 510                 if( *psz_synchro ) return 0;
 511                 return VPAR_SYNCHRO_IPplus;
 512
 513               case 'b':
 514               case 'B':
 515                 if( *psz_synchro ) return 0;
 516                 return VPAR_SYNCHRO_IPB;
 517
 518               default:
 519                 return VPAR_SYNCHRO_DEFAULT;
 520
 521             }
 522
 523           default:
 524             return VPAR_SYNCHRO_DEFAULT;
 525         }
 526     }
 527
 528     return VPAR_SYNCHRO_DEFAULT;
 529
 530 }
 531