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