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