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

   1 /*****************************************************************************
   2  * input.c: input thread
   3  * Read an MPEG2 stream, demultiplex and parse it before sending it to
   4  * decoders.
   5  *****************************************************************************
   6  * Copyright (C) 1998, 1999, 2000 VideoLAN
   7  *
   8  * Authors:
   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 GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public
  21  * License along with this program; if not, write to the
  22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 02111-1307, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include "defs.h"
  30
  31 #include <errno.h>                                                  /* errno */
  32 #include <sys/types.h>                        /* on BSD, uio.h needs types.h */
  33 #include <sys/uio.h>                                            /* "input.h" */
  34 #include <string.h>                                            /* strerror() */
  35
  36 #include <stdlib.h>                                                /* free() */
  37 #include <netinet/in.h>                                           /* ntohs() */
  38
  39 #include "config.h"
  40 #include "common.h"
  41 #include "threads.h"
  42 #include "mtime.h"
  43 #include "intf_msg.h"
  44 #include "plugins.h"
  45 #include "debug.h"
  46
  47 #include "input.h"
  48 #include "input_psi.h"
  49 #include "input_pcr.h"
  50 #include "input_netlist.h"
  51 #include "decoder_fifo.h"
  52 #include "input_file.h"
  53 #include "input_network.h"
  54
  55 #include "audio_output.h"                                   /* aout_thread_t */
  56
  57 #include "audio_decoder.h"        /* audiodec_t (for audio_decoder_thread.h) */
  58 #include "audio_decoder_thread.h"                           /* adec_thread_t */
  59
  60 #include "ac3_decoder.h"              /* ac3dec_t (for ac3_decoder_thread.h) */
  61 #include "ac3_decoder_thread.h"                           /* ac3dec_thread_t */
  62
  63 #include "lpcm_decoder.h"
  64 #include "lpcm_decoder_thread.h"
  65
  66 #include "video.h"                          /* picture_t (for video_output.h) */
  67 #include "video_output.h"                                   /* vout_thread_t */
  68
  69 #include "vdec_idct.h"                     /* dctelem_t (for video_parser.h) */
  70 #include "vdec_motion.h"                  /* f_motion_t (for video_parser.h) */
  71 #include "vpar_blocks.h"                /* macroblock_t (for video_parser.h) */
  72 #include "vpar_headers.h"                 /* sequence_t (for video_parser.h) */
  73 #include "vpar_synchro.h"            /* video_synchro_t (for video_parser.h) */
  74 #include "video_parser.h"                                   /* vpar_thread_t */
  75
  76 #include "spu_decoder.h"                                  /* spudec_thread_t */
  77
  78 #include "main.h"
  79
  80 /*****************************************************************************
  81  * Local prototypes
  82  *****************************************************************************/
  83 static void RunThread   ( input_thread_t *p_input );
  84 static void ErrorThread ( input_thread_t *p_input );
  85 static void EndThread   ( input_thread_t *p_input );
  86
  87 static __inline__ int   input_ReadPacket( input_thread_t *p_input );
  88 static __inline__ void  input_SortPacket( input_thread_t *p_input,
  89                                           ts_packet_t *ts_packet );
  90 static __inline__ void  input_DemuxTS( input_thread_t *p_input,
  91                                        ts_packet_t *ts_packet,
  92                                        es_descriptor_t *es_descriptor );
  93 static __inline__ void  input_DemuxPES( input_thread_t *p_input,
  94                                         ts_packet_t *ts_packet,
  95                                         es_descriptor_t *p_es_descriptor,
  96                                         boolean_t b_unit_start, boolean_t b_packet_lost );
  97 static __inline__ void  input_ParsePES( input_thread_t *p_input,
  98                                         es_descriptor_t *p_es_descriptor );
  99 static __inline__ void  input_DemuxPSI( input_thread_t *p_input,
 100                                         ts_packet_t *ts_packet,
 101                                         es_descriptor_t *p_es_descriptor,
 102                                         boolean_t b_unit_start, boolean_t b_packet_lost );
 103
 104 /*****************************************************************************
 105  * input_CreateThread: creates a new input thread
 106  *****************************************************************************
 107  * This function creates a new input, and returns a pointer
 108  * to its description. On error, it returns NULL.
 109  * If pi_status is NULL, then the function will block until the thread is ready.
 110  * If not, it will be updated using one of the THREAD_* constants.
 111  *****************************************************************************/
 112 input_thread_t *input_CreateThread ( int i_method, char *psz_source, int i_port, int i_vlan,
 113                                      p_vout_thread_t p_vout, p_aout_thread_t p_aout, int *pi_status )
 114 {
 115     input_thread_t *    p_input;                        /* thread descriptor */
 116     int                 i_status;                           /* thread status */
 117     int                 i_index;          /* index for tables initialization */
 118
 119     /* Allocate descriptor */
 120     intf_DbgMsg("\n");
 121     p_input = (input_thread_t *)malloc( sizeof(input_thread_t) );
 122     if( p_input == NULL )
 123     {
 124         intf_ErrMsg("error: %s\n", strerror(ENOMEM));
 125         return( NULL );
 126     }
 127
 128     /* Initialize thread properties */
 129     p_input->b_die              = 0;
 130     p_input->b_error            = 0;
 131     p_input->pi_status          = (pi_status != NULL) ? pi_status : &i_status;
 132     *p_input->pi_status         = THREAD_CREATE;
 133
 134     /* Initialize input method description */
 135     p_input->i_method           = i_method;
 136     p_input->psz_source         = psz_source;
 137     p_input->i_port             = i_port;
 138     p_input->i_vlan             = i_vlan;
 139     switch( i_method )
 140     {
 141     case INPUT_METHOD_TS_FILE:                               /* file methods */
 142         p_input->p_Open =   input_FileOpen;
 143         p_input->p_Read =   input_FileRead;
 144         p_input->p_Close =  input_FileClose;
 145         break;
 146     case INPUT_METHOD_TS_VLAN_BCAST:                  /* vlan network method */
 147         if( !p_main->b_vlans )
 148         {
 149             intf_ErrMsg("error: vlans are not activated\n");
 150             free( p_input );
 151             return( NULL );
 152         }
 153         /* ... pass through */
 154     case INPUT_METHOD_TS_UCAST:                           /* network methods */
 155     case INPUT_METHOD_TS_MCAST:
 156     case INPUT_METHOD_TS_BCAST:
 157         p_input->p_Open =   input_NetworkOpen;
 158         p_input->p_Read =   input_NetworkRead;
 159         p_input->p_Close =  input_NetworkClose;
 160         break;
 161     default:
 162         intf_ErrMsg("error: unknow input method\n");
 163         free( p_input );
 164         return( NULL );
 165         break;
 166     }
 167
 168     /* Initialize stream description */
 169     for( i_index = 0; i_index < INPUT_MAX_ES; i_index++ )
 170     {
 171         p_input->p_es[i_index].i_id = EMPTY_PID;
 172         p_input->pp_selected_es[i_index] = NULL;
 173     }
 174
 175     /* Initialize default settings for spawned decoders */
 176     p_input->p_aout                     = p_aout;
 177     p_input->p_vout                     = p_vout;
 178
 179 #ifdef STATS
 180     /* Initialize statistics */
 181     p_input->c_loops                    = 0;
 182     p_input->c_bytes                    = 0;
 183     p_input->c_payload_bytes            = 0;
 184     p_input->c_packets_read             = 0;
 185     p_input->c_packets_trashed          = 0;
 186 #endif
 187
 188     /* Initialize PSI and PCR decoders */
 189     if( input_PsiInit( p_input ) )
 190     {
 191         free( p_input );
 192         return( NULL );
 193     }
 194
 195     if( input_PcrInit( p_input ) )
 196     {
 197         input_PsiEnd( p_input );
 198         free( p_input );
 199         return( NULL );
 200     }
 201
 202     /* Initialize netlists */
 203     if( input_NetlistInit( p_input ) )
 204     {
 205         input_PsiEnd( p_input );
 206         input_PcrEnd( p_input );
 207         free( p_input );
 208         return( NULL );
 209     }
 210
 211     intf_DbgMsg("configuration: method=%d, source=%s, port=%d, vlan=%d\n",
 212                 i_method, psz_source, i_port, i_vlan );
 213
 214     /* Let the appropriate method open the socket. */
 215     if( p_input->p_Open( p_input ) )
 216     {
 217         input_NetlistEnd( p_input );
 218         input_PsiEnd( p_input );
 219         input_PcrEnd( p_input );
 220         free( p_input );
 221         return( NULL );
 222     }
 223
 224     /* Create thread and set locks. */
 225     vlc_mutex_init( &p_input->netlist.lock );
 226     vlc_mutex_init( &p_input->programs_lock );
 227     vlc_mutex_init( &p_input->es_lock );
 228     if( vlc_thread_create(&p_input->thread_id, "input", (void *) RunThread, (void *) p_input) )
 229     {
 230         intf_ErrMsg("error: %s\n", strerror(errno) );
 231         p_input->p_Close( p_input );
 232         input_NetlistEnd( p_input );;
 233         input_PsiEnd( p_input );
 234         input_PcrEnd( p_input );
 235         free( p_input );
 236         return( NULL );
 237     }
 238
 239     intf_Msg("Input initialized\n");
 240
 241     /* If status is NULL, wait until the thread is created */
 242     if( pi_status == NULL )
 243     {
 244         do
 245         {
 246             msleep( THREAD_SLEEP );
 247         }while( (i_status != THREAD_READY) && (i_status != THREAD_ERROR)
 248                 && (i_status != THREAD_FATAL) );
 249         if( i_status != THREAD_READY )
 250         {
 251             return( NULL );
 252         }
 253     }
 254     return( p_input );
 255 }
 256
 257 /*****************************************************************************
 258  * input_DestroyThread: mark an input thread as zombie
 259  *****************************************************************************
 260  * This function should not return until the thread is effectively cancelled.
 261  *****************************************************************************/
 262 void input_DestroyThread( input_thread_t *p_input, int *pi_status )
 263 {
 264     int         i_status;                                   /* thread status */
 265
 266     /* Set status */
 267     p_input->pi_status = (pi_status != NULL) ? pi_status : &i_status;
 268     *p_input->pi_status = THREAD_DESTROY;
 269
 270     /* Request thread destruction */
 271     p_input->b_die = 1;
 272
 273     /* If status is NULL, wait until thread has been destroyed */
 274     if( pi_status == NULL )
 275     {
 276         do
 277         {
 278             msleep( THREAD_SLEEP );
 279         }while( (i_status != THREAD_OVER) && (i_status != THREAD_ERROR)
 280                 && (i_status != THREAD_FATAL) );
 281     }
 282 }
 283
 284 #if 0
 285 /*****************************************************************************
 286  * input_OpenAudioStream: open an audio stream
 287  *****************************************************************************
 288  * This function spawns an audio decoder and plugs it on the audio output
 289  * thread.
 290  *****************************************************************************/
 291 int input_OpenAudioStream( input_thread_t *p_input, int i_id )
 292 {
 293     /* XXX?? */
 294 }
 295
 296 /*****************************************************************************
 297  * input_CloseAudioStream: close an audio stream
 298  *****************************************************************************
 299  * This function destroys an audio decoder.
 300  *****************************************************************************/
 301 void input_CloseAudioStream( input_thread_t *p_input, int i_id )
 302 {
 303     /* XXX?? */
 304 }
 305
 306 /*****************************************************************************
 307  * input_OpenVideoStream: open a video stream
 308  *****************************************************************************
 309  * This function spawns a video decoder and plugs it on a video output thread.
 310  *****************************************************************************/
 311 int input_OpenVideoStream( input_thread_t *p_input,
 312                            struct vout_thread_s *p_vout, struct video_cfg_s * p_cfg )
 313 {
 314     /* XXX?? */
 315 }
 316
 317 /*****************************************************************************
 318  * input_CloseVideoStream: close a video stream
 319  *****************************************************************************
 320  * This function destroys an video decoder.
 321  *****************************************************************************/
 322 void input_CloseVideoStream( input_thread_t *p_input, int i_id )
 323 {
 324     /* XXX?? */
 325 }
 326 #endif
 327
 328 /* following functions are local */
 329
 330 /*****************************************************************************
 331  * InitThread: initialize input thread
 332  *****************************************************************************
 333  * This function is called from RunThread and performs the second step of the
 334  * initialization. It returns 0 on success. Note that the thread's flag are not
 335  * modified inside this function.
 336  *****************************************************************************/
 337 static int InitThread( input_thread_t *p_input )
 338 {
 339     /* Mark thread as running and return */
 340     intf_DbgMsg("\n");
 341     *p_input->pi_status =        THREAD_READY;
 342     intf_DbgMsg("thread ready\n");
 343     return( 0 );
 344 }
 345
 346 /*****************************************************************************
 347  * RunThread: main thread loop
 348  *****************************************************************************
 349  * Thread in charge of processing the network packets and demultiplexing.
 350  *****************************************************************************/
 351 static void RunThread( input_thread_t *p_input )
 352 {
 353     /*
 354      * Initialize thread and free configuration
 355      */
 356     p_input->b_error = InitThread( p_input );
 357     if( p_input->b_error )
 358     {
 359         free( p_input );                               /* destroy descriptor */
 360         return;
 361     }
 362
 363     /*
 364      * Main loop
 365      */
 366     intf_DbgMsg("\n");
 367     while( !p_input->b_die && !p_input->b_error )
 368     {
 369         /* Scatter read the UDP packet from the network or the file. */
 370         if( (input_ReadPacket( p_input )) == (-1) )
 371         {
 372             /* FIXME??: Normally, a thread can't kill itself, but we don't have
 373              * any method in case of an error condition ... */
 374             p_input->b_error = 1;
 375         }
 376
 377 #ifdef STATS
 378         p_input->c_loops++;
 379 #endif
 380     }
 381
 382     /*
 383      * Error loop
 384      */
 385     if( p_input->b_error )
 386     {
 387         ErrorThread( p_input );
 388     }
 389
 390     /* End of thread */
 391     EndThread( p_input );
 392     intf_DbgMsg("thread end\n");
 393 }
 394
 395
 396 /*****************************************************************************
 397  * ErrorThread: RunThread() error loop
 398  *****************************************************************************
 399  * This function is called when an error occured during thread main's loop.
 400  *****************************************************************************/
 401 static void ErrorThread( input_thread_t *p_input )
 402 {
 403     /* Wait until a `die' order */
 404     intf_DbgMsg("\n");
 405     while( !p_input->b_die )
 406     {
 407         /* Sleep a while */
 408         msleep( VOUT_IDLE_SLEEP );
 409     }
 410 }
 411
 412 /*****************************************************************************
 413  * EndThread: end the input thread
 414  *****************************************************************************/
 415 static void EndThread( input_thread_t * p_input )
 416 {
 417     int *       pi_status;                                  /* threas status */
 418     int         i_es_loop;                                       /* es index */
 419
 420     /* Store status */
 421     intf_DbgMsg("\n");
 422     pi_status = p_input->pi_status;
 423     *pi_status = THREAD_END;
 424
 425     /* Close input method */
 426     p_input->p_Close( p_input );
 427
 428     /* Destroy all decoder threads */
 429     for( i_es_loop = 0;
 430          (i_es_loop < INPUT_MAX_ES) && (p_input->pp_selected_es[i_es_loop] != NULL) ;
 431          i_es_loop++ )
 432     {
 433         switch( p_input->pp_selected_es[i_es_loop]->i_type )
 434         {
 435         case MPEG1_VIDEO_ES:
 436         case MPEG2_VIDEO_ES:
 437 #ifdef OLD_DECODER
 438             vdec_DestroyThread( (vdec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
 439 #else
 440             vpar_DestroyThread( (vpar_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
 441 #endif
 442             break;
 443         case MPEG1_AUDIO_ES:
 444         case MPEG2_AUDIO_ES:
 445             adec_DestroyThread( (adec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 446             break;
 447         case AC3_AUDIO_ES:
 448             ac3dec_DestroyThread( (ac3dec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 449             break;
 450         case LPCM_AUDIO_ES:
 451             lpcmdec_DestroyThread((lpcmdec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 452             break;
 453         case DVD_SPU_ES:
 454             spudec_DestroyThread( (spudec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 455             break;
 456         case 0:
 457             /* Special streams for the PSI decoder, PID 0 and 1 */
 458             break;
 459 #ifdef DEBUG
 460         default:
 461             intf_DbgMsg("error: unknown decoder type %d\n", p_input->pp_selected_es[i_es_loop]->i_type );
 462             break;
 463 #endif
 464         }
 465     }
 466
 467     input_NetlistEnd( p_input );                            /* clean netlist */
 468     input_PsiEnd( p_input );                        /* clean PSI information */
 469     input_PcrEnd( p_input );                        /* clean PCR information */
 470     free( p_input );                          /* free input_thread structure */
 471
 472     /* Update status */
 473     *pi_status = THREAD_OVER;
 474 }
 475
 476 /*****************************************************************************
 477  * input_ReadPacket: reads a packet from the network or the file
 478  *****************************************************************************/
 479 static __inline__ int input_ReadPacket( input_thread_t *p_input )
 480 {
 481     int                 i_base_index; /* index of the first free iovec */
 482     int                 i_current_index;
 483     int                 i_packet_size;
 484 #ifdef INPUT_LIFO_TS_NETLIST
 485     int                 i_meanwhile_released;
 486     int                 i_currently_removed;
 487 #endif
 488     ts_packet_t *       p_ts_packet;
 489
 490     /* In this function, we only care about the TS netlist. PES netlist
 491      * is for the demultiplexer. */
 492 #ifdef INPUT_LIFO_TS_NETLIST
 493     i_base_index = p_input->netlist.i_ts_index;
 494
 495     /* Verify that we still have packets in the TS netlist */
 496     if( (INPUT_MAX_TS + INPUT_TS_READ_ONCE - 1 - p_input->netlist.i_ts_index) <= INPUT_TS_READ_ONCE )
 497     {
 498         intf_ErrMsg("input error: TS netlist is empty !\n");
 499         return( -1 );
 500     }
 501
 502 #else /* FIFO netlist */
 503     i_base_index = p_input->netlist.i_ts_start;
 504     if( p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE -1 > INPUT_MAX_TS )
 505     {
 506         /* The netlist is splitted in 2 parts. We must gather them to consolidate
 507            the FIFO (we make the loop easily in having the same iovec at the far
 508            end and in the beginning of netlist_free).
 509            That's why the netlist is (INPUT_MAX_TS +1) + (INPUT_TS_READ_ONCE -1)
 510            large. */
 511         memcpy( p_input->netlist.p_ts_free + INPUT_MAX_TS + 1,
 512                 p_input->netlist.p_ts_free,
 513                 (p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE - 1 - INPUT_MAX_TS)
 514                   * sizeof(struct iovec) );
 515     }
 516
 517     /* Verify that we still have packets in the TS netlist */
 518     if( ((p_input->netlist.i_ts_end -1 - p_input->netlist.i_ts_start) & INPUT_MAX_TS) <= INPUT_TS_READ_ONCE )
 519     {
 520         intf_ErrMsg("input error: TS netlist is empty !\n");
 521         return( -1 );
 522     }
 523 #endif /* FIFO netlist */
 524
 525     /* Scatter read the buffer. */
 526     i_packet_size = (*p_input->p_Read)( p_input,
 527                            &p_input->netlist.p_ts_free[i_base_index],
 528                            INPUT_TS_READ_ONCE );
 529     if( i_packet_size == (-1) )
 530     {
 531 #if 0
 532         intf_DbgMsg("Read packet %d %p %d %d\n", i_base_index,
 533                     &p_input->netlist.p_ts_free[i_base_index],
 534                     p_input->netlist.i_ts_start,
 535                     p_input->netlist.i_ts_end);
 536 #endif
 537         intf_ErrMsg("input error: readv() failed (%s)\n", strerror(errno));
 538         return( -1 );
 539     }
 540
 541     if( i_packet_size == 0 )
 542     {
 543         /* No packet has been received, so stop here. */
 544         return( 0 );
 545     }
 546
 547     /* Demultiplex the TS packets (1..INPUT_TS_READ_ONCE) received. */
 548     for( i_current_index = i_base_index;
 549          (i_packet_size -= TS_PACKET_SIZE) >= 0;
 550          i_current_index++ )
 551     {
 552         /* BTW, something REALLY bad could happen if we receive packets with
 553            a wrong size. */
 554         p_ts_packet = (ts_packet_t*)(p_input->netlist.p_ts_free[i_current_index].iov_base);
 555         /* Don't cry :-), we are allowed to do that cast, because initially,
 556            our buffer was malloc'ed with sizeof(ts_packet_t) */
 557
 558         /* Find out if we need this packet and demultiplex. */
 559         input_SortPacket( p_input /* for current PIDs and netlist */,
 560                           p_ts_packet);
 561     }
 562
 563     if( i_packet_size > 0 )
 564     {
 565         intf_ErrMsg("input error: wrong size\n");
 566         return( -1 );
 567     }
 568
 569     /* Remove the TS packets we have just filled from the netlist */
 570 #ifdef INPUT_LIFO_TS_NETLIST
 571     /* We need to take a lock here while we're calculating index positions. */
 572     vlc_mutex_lock( &p_input->netlist.lock );
 573
 574     i_meanwhile_released = i_base_index - p_input->netlist.i_ts_index;
 575     if( i_meanwhile_released )
 576     {
 577         /* That's where it becomes funny :-). Since we didn't take locks for
 578            efficiency reasons, other threads (including ourselves, with
 579            input_DemuxPacket) might have released packets to the netlist.
 580            So we have to copy these iovec where they should go.
 581
 582            BTW, that explains why the TS netlist is
 583            (INPUT_MAX_TS +1) + (TS_READ_ONCE -1) large. */
 584
 585         i_currently_removed = i_current_index - i_base_index;
 586         if( i_meanwhile_released < i_currently_removed )
 587         {
 588             /* Copy all iovecs in that case */
 589             memcpy( &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index]
 590                      + i_currently_removed,
 591                     &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
 592                     i_meanwhile_released * sizeof(struct iovec) );
 593         }
 594         else
 595         {
 596             /* We have fewer places than items, so we only move
 597                i_currently_removed of them. */
 598             memcpy( &p_input->netlist.p_ts_free[i_base_index],
 599                     &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
 600                     i_currently_removed * sizeof(struct iovec) );
 601         }
 602
 603         /* Update i_netlist_index with the information gathered above. */
 604         p_input->netlist.i_ts_index += i_currently_removed;
 605     }
 606     else
 607     {
 608         /* Nothing happened. */
 609         p_input->netlist.i_ts_index = i_current_index;
 610     }
 611
 612     vlc_mutex_unlock( &p_input->netlist.lock );
 613
 614 #else /* FIFO netlist */
 615     /* & is modulo ; that's where we make the loop. */
 616     p_input->netlist.i_ts_start = i_current_index & INPUT_MAX_TS;
 617 #endif
 618
 619 #ifdef STATS
 620     p_input->c_packets_read += i_current_index - i_base_index;
 621     p_input->c_bytes += (i_current_index - i_base_index) * TS_PACKET_SIZE;
 622 #endif
 623     return( 0 );
 624 }
 625
 626 /*****************************************************************************
 627  * input_SortPacket: find out whether we need that packet
 628  *****************************************************************************/
 629 static __inline__ void input_SortPacket( input_thread_t *p_input,
 630                                          ts_packet_t *p_ts_packet )
 631 {
 632     int             i_current_pid;
 633     int             i_es_loop;
 634
 635     /* Verify that sync_byte, error_indicator and scrambling_control are
 636        what we expected. */
 637     if( !(p_ts_packet->buffer[0] == 0x47) || (p_ts_packet->buffer[1] & 0x80) ||
 638         (p_ts_packet->buffer[3] & 0xc0) )
 639     {
 640         intf_DbgMsg("input debug: invalid TS header (%p)\n", p_ts_packet);
 641     }
 642     else
 643     {
 644         /* Get the PID of the packet. Note that ntohs is needed, for endianness
 645            purposes (see man page). */
 646         i_current_pid = U16_AT(&p_ts_packet->buffer[1]) & 0x1fff;
 647
 648         //intf_DbgMsg("input debug: pid %d received (%p)\n",
 649         //            i_current_pid, p_ts_packet);
 650
 651         /* Lock current ES state. */
 652         vlc_mutex_lock( &p_input->es_lock );
 653
 654     /* Verify that we actually want this PID. */
 655         for( i_es_loop = 0; i_es_loop < INPUT_MAX_SELECTED_ES; i_es_loop++ )
 656         {
 657             if( p_input->pp_selected_es[i_es_loop] != NULL)
 658             {
 659                 if( (*p_input->pp_selected_es[i_es_loop]).i_id
 660                      == i_current_pid )
 661                 {
 662                     /* Don't need the lock anymore, since the value pointed
 663                        out by p_input->pp_selected_es[i_es_loop] can only be
 664                        modified from inside the input_thread (by the PSI
 665                        decoder): interface thread is only allowed to modify
 666                        the pp_selected_es table */
 667                     vlc_mutex_unlock( &p_input->es_lock );
 668
 669                     /* We're interested. Pass it to the demultiplexer. */
 670                     input_DemuxTS( p_input, p_ts_packet,
 671                                    p_input->pp_selected_es[i_es_loop] );
 672                     return;
 673                 }
 674             }
 675             else
 676             {
 677                 /* pp_selected_es should not contain any hole. */
 678                 break;
 679             }
 680         }
 681         vlc_mutex_unlock( &p_input->es_lock );
 682     }
 683
 684     /* We weren't interested in receiving this packet. Give it back to the
 685        netlist. */
 686     //intf_DbgMsg("SortPacket: freeing unwanted TS %p (pid %d)\n", p_ts_packet,
 687     //                 U16_AT(&p_ts_packet->buffer[1]) & 0x1fff);
 688     input_NetlistFreeTS( p_input, p_ts_packet );
 689 #ifdef STATS
 690     p_input->c_packets_trashed++;
 691 #endif
 692 }
 693
 694 /*****************************************************************************
 695  * input_DemuxTS: first step of demultiplexing: the TS header
 696  *****************************************************************************
 697  * Stream must also only contain PES and PSI, so PID must have been filtered
 698  *****************************************************************************/
 699 static __inline__ void input_DemuxTS( input_thread_t *p_input,
 700                                       ts_packet_t *p_ts_packet,
 701                                       es_descriptor_t *p_es_descriptor )
 702 {
 703     int         i_dummy;
 704     boolean_t   b_adaption;                     /* Adaption field is present */
 705     boolean_t   b_payload;                         /* Packet carries payload */
 706     boolean_t   b_unit_start;          /* A PSI or a PES start in the packet */
 707     boolean_t   b_trash = 0;                 /* Must the packet be trashed ? */
 708     boolean_t   b_lost = 0;                     /* Was there a packet lost ? */
 709
 710     ASSERT(p_input);
 711     ASSERT(p_ts_packet);
 712     ASSERT(p_es_descriptor);
 713
 714 #define p (p_ts_packet->buffer)
 715
 716     //intf_DbgMsg("input debug: TS-demultiplexing packet %p, pid %d, number %d\n",
 717     //            p_ts_packet, U16_AT(&p[1]) & 0x1fff, p[3] & 0x0f);
 718
 719 #ifdef STATS
 720     p_es_descriptor->c_packets++;
 721     p_es_descriptor->c_bytes += TS_PACKET_SIZE;
 722 #endif
 723
 724     /* Extract flags values from TS common header. */
 725     b_unit_start = (p[1] & 0x40);
 726     b_adaption = (p[3] & 0x20);
 727     b_payload = (p[3] & 0x10);
 728
 729     /* Extract adaption field informations if any */
 730     if( !b_adaption )
 731     {
 732         /* We don't have any adaptation_field, so payload start immediately
 733            after the 4 byte TS header */
 734         p_ts_packet->i_payload_start = 4;
 735     }
 736     else
 737     {
 738         /* p[4] is adaptation_field_length minus one */
 739         p_ts_packet->i_payload_start = 5 + p[4];
 740
 741         /* The adaption field can be limited to the adaptation_field_length byte,
 742            so that there is nothing to do: skip this possibility */
 743         if( p[4] )
 744         {
 745             /* If the packet has both adaptation_field and payload, adaptation_field
 746                cannot be more than 182 bytes long; if there is only an
 747                adaptation_field, it must fill the next 183 bytes. */
 748             if( b_payload ? (p[4] > 182) : (p[4] != 183) )
 749             {
 750                 intf_DbgMsg("input debug: invalid TS adaptation field (%p)\n",
 751                             p_ts_packet);
 752 #ifdef STATS
 753                 p_es_descriptor->c_invalid_packets++;
 754 #endif
 755                 b_trash = 1;
 756             }
 757
 758             /* No we are sure that the byte containing flags is present: read it */
 759             else
 760             {
 761                 /* discontinuity_indicator */
 762                 if( p[5] & 0x80 )
 763                 {
 764                     intf_DbgMsg("discontinuity_indicator encountered by TS demux " \
 765                                 "(position read: %d, saved: %d)\n", p[5] & 0x80,
 766                                 p_es_descriptor->i_continuity_counter);
 767
 768                     /* If the PID carries the PCR, there will be a system time-base
 769                        discontinuity. We let the PCR decoder handle that. */
 770                     p_es_descriptor->b_discontinuity = 1;
 771
 772                     /* There also may be a continuity_counter discontinuity:
 773                resynchronise our counter with the one of the stream */
 774                     p_es_descriptor->i_continuity_counter = (p[3] & 0x0f) - 1;
 775                 }
 776
 777                 /* random_access_indicator */
 778                 p_es_descriptor->b_random |= p[5] & 0x40;
 779
 780                 /* If this is a PCR_PID, and this TS packet contains a PCR,
 781            we pass it along to the PCR decoder. */
 782                 if( (p_es_descriptor->b_pcr) && (p[5] & 0x10) )
 783                 {
 784                     /* There should be a PCR field in the packet, check if the
 785                adaption field is long enough to carry it */
 786                     if( p[4] >= 7 )
 787                     {
 788                         /* Call the PCR decoder */
 789                         input_PcrDecode( p_input, p_es_descriptor, &p[6] );
 790                     }
 791                 }
 792             }
 793         }
 794     }
 795
 796     /* Check the continuity of the stream. */
 797     i_dummy = ((p[3] & 0x0f) - p_es_descriptor->i_continuity_counter) & 0x0f;
 798     if( i_dummy == 1 )
 799     {
 800         /* Everything is ok, just increase our counter */
 801         p_es_descriptor->i_continuity_counter++;
 802     }
 803     else
 804     {
 805         if( !b_payload && i_dummy == 0 )
 806         {
 807             /* This is a packet without payload, this is allowed by the draft
 808                As there is nothing interesting in this packet (except PCR that
 809                have already been handled), we can trash the packet. */
 810             intf_DbgMsg("Packet without payload received by TS demux\n");
 811             b_trash = 1;
 812         }
 813         else if( i_dummy <= 0 )
 814         {
 815             /* Duplicate packet: mark it as being to be trashed. */
 816             intf_DbgMsg("Duplicate packet received by TS demux\n");
 817             b_trash = 1;
 818         }
 819         else if( p_es_descriptor->i_continuity_counter == 0xFF )
 820         {
 821             /* This means that the packet is the first one we receive for this
 822                ES since the continuity counter ranges between 0 and 0x0F
 823                excepts when it has been initialized by the input: Init the
 824                counter to the correct value. */
 825             intf_DbgMsg("First packet for PID %d received by TS demux\n",
 826                         p_es_descriptor->i_id);
 827             p_es_descriptor->i_continuity_counter = (p[3] & 0x0f);
 828         }
 829         else
 830         {
 831             /* This can indicate that we missed a packet or that the
 832                continuity_counter wrapped and we received a dup packet: as we
 833                don't know, do as if we missed a packet to be sure to recover
 834                from this situation */
 835             intf_DbgMsg("Packet lost by TS demux: current %d, packet %d\n",
 836                         p_es_descriptor->i_continuity_counter & 0x0f,
 837                         p[3] & 0x0f);
 838             b_lost = 1;
 839             p_es_descriptor->i_continuity_counter = p[3] & 0x0f;
 840         }
 841     }
 842
 843     /* Trash the packet if it has no payload or if it is bad */
 844     if( b_trash )
 845     {
 846         input_NetlistFreeTS( p_input, p_ts_packet );
 847 #ifdef STATS
 848         p_input->c_packets_trashed++;
 849 #endif
 850     }
 851     else
 852     {
 853         if( p_es_descriptor->b_psi )
 854         {
 855             /* The payload contains PSI tables */
 856             input_DemuxPSI( p_input, p_ts_packet, p_es_descriptor,
 857                             b_unit_start, b_lost );
 858         }
 859         else
 860         {
 861             /* The payload carries a PES stream */
 862             input_DemuxPES( p_input, p_ts_packet, p_es_descriptor,
 863                             b_unit_start, b_lost );
 864         }
 865     }
 866
 867 #undef p
 868 }
 869
 870
 871
 872
 873 /*****************************************************************************
 874  * input_DemuxPES:
 875  *****************************************************************************
 876  * Gather a PES packet.
 877  *****************************************************************************/
 878 static __inline__ void input_DemuxPES( input_thread_t *p_input,
 879                                        ts_packet_t *p_ts_packet,
 880                                        es_descriptor_t *p_es_descriptor,
 881                                        boolean_t b_unit_start,
 882                                        boolean_t b_packet_lost )
 883 {
 884     int                         i_dummy;
 885     pes_packet_t*               p_last_pes;
 886     ts_packet_t *               p_ts;
 887     int                         i_ts_payload_size;
 888
 889
 890 #define p_pes (p_es_descriptor->p_pes_packet)
 891
 892     ASSERT(p_input);
 893     ASSERT(p_ts_packet);
 894     ASSERT(p_es_descriptor);
 895
 896     //intf_DbgMsg("PES-demultiplexing %p (%p)\n", p_ts_packet, p_pes);
 897
 898     /* If we lost data, discard the PES packet we are trying to reassemble
 899        if any and wait for the beginning of a new one in order to synchronise
 900        again */
 901     if( b_packet_lost && p_pes != NULL )
 902     {
 903         intf_DbgMsg("PES %p trashed because of packet lost\n", p_pes);
 904         input_NetlistFreePES( p_input, p_pes );
 905         p_pes = NULL;
 906     }
 907
 908     /* If the TS packet contains the begining of a new PES packet, and if we
 909        were reassembling a PES packet, then the PES should be complete now,
 910        so parse its header and give it to the decoders */
 911     if( b_unit_start && p_pes != NULL )
 912     {
 913         /* Parse the header. The header has a variable length, but in order
 914            to improve the algorithm, we will read the 14 bytes we may be
 915            interested in */
 916
 917         /* If this part of the header did not fit in the current TS packet,
 918            copy the part of the header we are interested in to the
 919            p_pes_header_save buffer. The buffer is dynamicly allocated if
 920            needed so it's time expensive but this situation almost never
 921            occurs. */
 922         p_ts = p_pes->p_first_ts;
 923         i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
 924
 925         if(i_ts_payload_size < PES_HEADER_SIZE)
 926         {
 927             intf_DbgMsg("Code never tested encountered, WARNING ! (benny)\n");
 928             if( !p_pes->p_pes_header_save )
 929             {
 930                 p_pes->p_pes_header_save = malloc(PES_HEADER_SIZE);
 931             }
 932
 933             i_dummy = 0;
 934             do
 935             {
 936                 memcpy(p_pes->p_pes_header_save + i_dummy,
 937                        &p_ts->buffer[p_ts->i_payload_start], i_ts_payload_size);
 938                 i_dummy += i_ts_payload_size;
 939
 940                 p_ts = p_ts->p_next_ts;
 941                 if(!p_ts)
 942                 {
 943                   /* The payload of the PES packet is shorter than the 14 bytes
 944                      we would read. This means that high packet lost occured
 945                      so the PES won't be useful for any decoder. Moreover,
 946                      this should never happen so we can trash the packet and
 947                      exit roughly without regrets */
 948                   intf_DbgMsg("PES packet too short: trashed\n");
 949                   input_NetlistFreePES( p_input, p_pes );
 950                   p_pes = NULL;
 951                   /* Stats XXX?? */
 952                   return;
 953                 }
 954
 955                 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
 956             }
 957             while(i_ts_payload_size + i_dummy < PES_HEADER_SIZE);
 958
 959             /* This last TS packet is partly header, partly payload, so just
 960                copy the header part */
 961             memcpy(p_pes->p_pes_header_save + i_dummy,
 962                    &p_ts->buffer[p_ts->i_payload_start],
 963                    PES_HEADER_SIZE - i_dummy);
 964
 965             /* The header must be read in the buffer not in any TS packet */
 966             p_pes->p_pes_header = p_pes->p_pes_header_save;
 967
 968             /* Get the PES size if defined */
 969             if( (i_dummy = U16_AT(p_pes->p_pes_header + 4)) )
 970             {
 971                 p_pes->i_pes_real_size = i_dummy + 6;
 972             }
 973         }
 974
 975         /* Now we have the part of the PES header we were interested in:
 976            p_pes_header and i_pes_real_size ; we can parse it */
 977         input_ParsePES( p_input, p_es_descriptor );
 978     }
 979
 980     /* If we are at the beginning of a new PES packet, we must fetch a new
 981        PES buffer to begin with the reassembly of this PES packet. This is
 982        also here that we can synchronise with the stream if we we lost
 983        packets or if the decoder has just started */
 984     if( b_unit_start )
 985     {
 986         p_last_pes = p_pes;
 987
 988         /* Get a new one PES from the PES netlist. */
 989         if( (p_pes = input_NetlistGetPES( p_input )) == (NULL) )
 990         {
 991             /* PES netlist is empty ! */
 992             p_input->b_error = 1;
 993         }
 994         else
 995         {
 996             //intf_DbgMsg("New PES packet %p (first TS: %p)\n", p_pes, p_ts_packet);
 997
 998             /* Init the PES fields so that the first TS packet could be
 999              * correctly added to the PES packet (see below) */
1000             p_pes->p_first_ts = p_ts_packet;
1001             p_pes->p_last_ts = NULL;
1002
1003             /* If the last pes packet was null, this means that the
1004              * synchronization was lost and so warn the decoder that he
1005              * will have to find a way to recover */
1006             if( !p_last_pes )
1007                 p_pes->b_data_loss = 1;
1008
1009             /* Read the b_random_access flag status and then reinit it */
1010             p_pes->b_random_access = p_es_descriptor->b_random;
1011             p_es_descriptor->b_random = 0;
1012         }
1013
1014         /* If the PES header fits in the first TS packet, we can
1015          * already set p_pes->p_pes_header, and in all cases we
1016          * set p_pes->i_pes_real_size */
1017         if( p_ts_packet->i_payload_end - p_ts_packet->i_payload_start
1018                 >= PES_HEADER_SIZE )
1019         {
1020             p_pes->p_pes_header = &(p_ts_packet->buffer[p_ts_packet->i_payload_start]);
1021             if( (i_dummy = U16_AT(p_pes->p_pes_header + 4)) )
1022             {
1023                 p_pes->i_pes_real_size = i_dummy + 6;
1024             }
1025         }
1026     }
1027
1028
1029     /* If we are synchronized with the stream, and so if we are ready to
1030        receive correctly the data, add the TS packet to the current PES
1031        packet */
1032     if( p_pes != NULL )
1033     {
1034         //intf_DbgMsg("Adding TS %p to PES %p\n", p_ts_packet, p_pes);
1035
1036         /* Size of the payload carried in the TS packet */
1037         i_ts_payload_size = p_ts_packet->i_payload_end -
1038                             p_ts_packet->i_payload_start;
1039
1040         /* Update the relations between the TS packets */
1041         p_ts_packet->p_prev_ts = p_pes->p_last_ts;
1042         p_ts_packet->p_next_ts = NULL;
1043         if( p_pes->i_ts_packets != 0 )
1044         {
1045             /* Regarder si il serait pas plus efficace de ne creer que
1046              * les liens precedent->suivant pour le moment, et les
1047              * liens suivant->precedent quand le paquet est termine */
1048             /* Otherwise it is the first TS packet. */
1049             p_pes->p_last_ts->p_next_ts = p_ts_packet;
1050         }
1051         /* Now add the TS to the PES packet */
1052         p_pes->p_last_ts = p_ts_packet;
1053         p_pes->i_ts_packets++;
1054         p_pes->i_pes_size += i_ts_payload_size;
1055
1056         /* Stats */
1057 #ifdef STATS
1058         i_dummy = p_ts_packet->i_payload_end - p_ts_packet->i_payload_start;
1059         p_es_descriptor->c_payload_bytes += i_dummy;
1060 #endif
1061
1062         /* We can check if the packet is finished */
1063         if( p_pes->i_pes_size == p_pes->i_pes_real_size )
1064         {
1065             /* The packet is finished, parse it */
1066             input_ParsePES( p_input, p_es_descriptor );
1067
1068             /* Tell the Demux we have parsed this PES, no need to redo it */
1069             p_pes = NULL;
1070         }
1071     }
1072     else
1073     {
1074         /* Since we don't use the TS packet to build a PES packet, we don't
1075            need it anymore, so give it back to the netlist */
1076         //intf_DbgMsg("Trashing TS %p: no PES being build\n", p_ts_packet);
1077         input_NetlistFreeTS( p_input, p_ts_packet );
1078     }
1079
1080 #undef p_pes
1081 }
1082
1083
1084
1085 /*****************************************************************************
1086  * input_ParsePES
1087  *****************************************************************************
1088  * Parse a finished PES packet and analyze its header.
1089  *****************************************************************************/
1090 static __inline__ void input_ParsePES( input_thread_t *p_input,
1091                                        es_descriptor_t *p_es_descriptor )
1092 {
1093     decoder_fifo_t *            p_fifo;
1094     u8                          i_pes_header_size;
1095     ts_packet_t *               p_ts;
1096     int                         i_ts_payload_size;
1097
1098
1099 #define p_pes (p_es_descriptor->p_pes_packet)
1100
1101     //intf_DbgMsg("End of PES packet %p\n", p_pes);
1102
1103     /* First read the 6 header bytes common to all PES packets:
1104        use them to test the PES validity */
1105     if( (p_pes->p_pes_header[0] || p_pes->p_pes_header[1] ||
1106         (p_pes->p_pes_header[2] != 1)) ||
1107                                  /* packet_start_code_prefix != 0x000001 */
1108         ((p_pes->i_pes_real_size) &&
1109          (p_pes->i_pes_real_size != p_pes->i_pes_size)) )
1110                /* PES_packet_length is set and != total received payload */
1111     {
1112       /* Trash the packet and set p_pes to NULL to be sure the next PES
1113          packet will have its b_data_lost flag set */
1114       intf_DbgMsg("Corrupted PES packet received: trashed\n");
1115       input_NetlistFreePES( p_input, p_pes );
1116       p_pes = NULL;
1117       /* Stats XXX?? */
1118     }
1119     else
1120     {
1121         /* The PES packet is valid. Check its type to test if it may
1122            carry additional informations in a header extension */
1123         p_pes->i_stream_id =  p_pes->p_pes_header[3];
1124
1125         switch( p_pes->i_stream_id )
1126         {
1127         case 0xBE:  /* Padding */
1128         case 0xBC:  /* Program stream map */
1129         case 0xBF:  /* Private stream 2 */
1130         case 0xB0:  /* ECM */
1131         case 0xB1:  /* EMM */
1132         case 0xFF:  /* Program stream directory */
1133         case 0xF2:  /* DSMCC stream */
1134         case 0xF8:  /* ITU-T H.222.1 type E stream */
1135             /* The payload begins immediatly after the 6 bytes header, so
1136                we have finished with the parsing */
1137             i_pes_header_size = 6;
1138             break;
1139
1140         default:
1141             /* The PES header contains at least 3 more bytes: parse them */
1142             p_pes->b_data_alignment = p_pes->p_pes_header[6] & 0x04;
1143             p_pes->b_has_pts = p_pes->p_pes_header[7] & 0x80;
1144             i_pes_header_size = p_pes->p_pes_header[8] + 9;
1145
1146             /* Now parse the optional header extensions (in the limit of
1147                the 14 bytes */
1148             if( p_pes->b_has_pts )
1149             {
1150                 pcr_descriptor_t * p_pcr;
1151
1152                 p_pcr = p_input->p_pcr;
1153
1154                 p_pes->i_pts =
1155                     ( ((mtime_t)(p_pes->p_pes_header[9] & 0x0E) << 29) |
1156                       (((mtime_t)U16_AT(p_pes->p_pes_header + 10) << 14) - (1 << 14)) |
1157                       ((mtime_t)U16_AT(p_pes->p_pes_header + 12) >> 1) ) * 300;
1158                 p_pes->i_pts /= 27;
1159
1160                 if( p_pcr->i_synchro_state )
1161                 {
1162                     switch( p_pcr->i_synchro_state )
1163                     {
1164                         case SYNCHRO_NOT_STARTED:
1165                             p_pes->b_has_pts = 0;
1166                             break;
1167
1168                         case SYNCHRO_START:
1169                             p_pes->i_pts += p_pcr->delta_pcr;
1170                             p_pcr->delta_absolute = mdate() - p_pes->i_pts + INPUT_PTS_DELAY;
1171                             p_pes->i_pts += p_pcr->delta_absolute;
1172                             p_pcr->i_synchro_state = 0;
1173                             break;
1174
1175                         case SYNCHRO_REINIT: /* We skip a PES */
1176                             p_pes->b_has_pts = 0;
1177                             p_pcr->i_synchro_state = SYNCHRO_START;
1178                             break;
1179                     }
1180                 }
1181                 else
1182                 {
1183                     p_pes->i_pts += p_pcr->delta_pcr + p_pcr->delta_absolute;
1184                 }
1185             }
1186             break;
1187         }
1188
1189         /* Now we've parsed the header, we just have to indicate in some
1190            specific TS packets where the PES payload begins (renumber
1191            i_payload_start), so that the decoders can find the beginning
1192            of their data right out of the box. */
1193         p_ts = p_pes->p_first_ts;
1194         i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
1195         while( i_pes_header_size > i_ts_payload_size )
1196         {
1197             /* These packets are entirely filled by the PES header. */
1198             i_pes_header_size -= i_ts_payload_size;
1199             p_ts->i_payload_start = p_ts->i_payload_end;
1200             /* Go to the next TS packet: here we won't have to test it is
1201                not NULL because we trash the PES packets when packet lost
1202                occurs */
1203             p_ts = p_ts->p_next_ts;
1204             i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
1205         }
1206         /* This last packet is partly header, partly payload. */
1207         p_ts->i_payload_start += i_pes_header_size;
1208
1209
1210         /* Now we can eventually put the PES packet in the decoder's
1211            PES fifo */
1212         switch( p_es_descriptor->i_type )
1213         {
1214             case MPEG1_VIDEO_ES:
1215             case MPEG2_VIDEO_ES:
1216 #ifdef OLD_DECODER
1217                 p_fifo = &(((vdec_thread_t*)(p_es_descriptor->p_dec))->fifo);
1218 #else
1219                 p_fifo = &(((vpar_thread_t*)(p_es_descriptor->p_dec))->fifo);
1220 #endif
1221                 break;
1222
1223             case MPEG1_AUDIO_ES:
1224             case MPEG2_AUDIO_ES:
1225                 p_fifo = &(((adec_thread_t*)(p_es_descriptor->p_dec))->fifo);
1226                 break;
1227
1228             case AC3_AUDIO_ES:
1229                 /* we skip 4 bytes at the beginning of the AC3 payload */
1230                 //p_ts->i_payload_start += 4;
1231                 p_fifo = &(((ac3dec_thread_t *)(p_es_descriptor->p_dec))->fifo);
1232                 break;
1233
1234             case LPCM_AUDIO_ES:
1235                 p_fifo = &(((lpcmdec_thread_t *)(p_es_descriptor->p_dec))->fifo);
1236                 break;
1237
1238             case DVD_SPU_ES:
1239                 /* we skip the first byte at the beginning of the
1240                  * subpicture payload, it only contains the SPU ID. */
1241                 p_ts->i_payload_start++;
1242                 p_fifo = &(((spudec_thread_t *)(p_es_descriptor->p_dec))->fifo);
1243                 break;
1244
1245             default:
1246                 /* This should never happen */
1247                 intf_DbgMsg("Unknown stream type (%d, %d): PES trashed\n",
1248                     p_es_descriptor->i_id, p_es_descriptor->i_type);
1249                 p_fifo = NULL;
1250                 break;
1251         }
1252
1253         if( p_fifo != NULL )
1254         {
1255             vlc_mutex_lock( &p_fifo->data_lock );
1256             if( DECODER_FIFO_ISFULL( *p_fifo ) )
1257             {
1258                 /* The FIFO is full !!! This should not happen. */
1259 #ifdef STATS
1260                 p_input->c_packets_trashed += p_pes->i_ts_packets;
1261                 p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
1262 #endif
1263                 input_NetlistFreePES( p_input, p_pes );
1264                 intf_DbgMsg("PES trashed - fifo full ! (%d, %d)\n",
1265                            p_es_descriptor->i_id, p_es_descriptor->i_type);
1266             }
1267         else
1268             {
1269                 //intf_DbgMsg("Putting %p into fifo %p/%d\n",
1270                 //            p_pes, p_fifo, p_fifo->i_end);
1271                 p_fifo->buffer[p_fifo->i_end] = p_pes;
1272                 DECODER_FIFO_INCEND( *p_fifo );
1273
1274                 /* Warn the decoder that it's got work to do. */
1275                 vlc_cond_signal( &p_fifo->data_wait );
1276             }
1277             vlc_mutex_unlock( &p_fifo->data_lock );
1278         }
1279         else
1280         {
1281             intf_DbgMsg("No fifo to receive PES %p: trash\n", p_pes);
1282 #ifdef STATS
1283             p_input->c_packets_trashed += p_pes->i_ts_packets;
1284             p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
1285 #endif
1286             input_NetlistFreePES( p_input, p_pes );
1287         }
1288     }
1289 #undef p_pes
1290 }
1291
1292
1293
1294 /*****************************************************************************
1295  * input_DemuxPSI:
1296  *****************************************************************************
1297  * Notice that current ES state has been locked by input_SortPacket. (No more true,
1298  * changed by benny - FIXME: See if it's ok, and definitely change the code ?? )
1299  *****************************************************************************/
1300 static __inline__ void input_DemuxPSI( input_thread_t *p_input,
1301                                        ts_packet_t *p_ts_packet,
1302                                        es_descriptor_t *p_es_descriptor,
1303                                        boolean_t b_unit_start, boolean_t b_packet_lost )
1304 {
1305     int i_data_offset;    /* Offset of the interesting data in the TS packet */
1306     u16 i_data_length;                               /* Length of those data */
1307     //boolean_t b_first_section; /* Was there another section in the TS packet ? */
1308
1309     ASSERT(p_input);
1310     ASSERT(p_ts_packet);
1311     ASSERT(p_es_descriptor);
1312
1313 #define p_psi (p_es_descriptor->p_psi_section)
1314
1315     //intf_DbgMsg( "input debug: PSI demultiplexing %p (%p)\n", p_ts_packet, p_input);
1316
1317     //intf_DbgMsg( "Packet: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x (unit start: %d)\n", p_ts_packet->buffer[p_ts_packet->i_payload_start], p_ts_packet->buffer[p_ts_packet->i_payload_start+1], p_ts_packet->buffer[p_ts_packet->i_payload_start+2], p_ts_packet->buffer[p_ts_packet->i_payload_start+3], p_ts_packet->buffer[p_ts_packet->i_payload_start+4], p_ts_packet->buffer[p_ts_packet->i_payload_start+5], p_ts_packet->buffer[p_ts_packet->i_payload_start+6], p_ts_packet->buffer[p_ts_packet->i_payload_start+7], p_ts_packet->buffer[p_ts_packet->i_payload_start+8], p_ts_packet->buffer[p_ts_packet->i_payload_start+9], p_ts_packet->buffer[p_ts_packet->i_payload_start+10], p_ts_packet->buffer[p_ts_packet->i_payload_start+11], p_ts_packet->buffer[p_ts_packet->i_payload_start+12], p_ts_packet->buffer[p_ts_packet->i_payload_start+13], p_ts_packet->buffer[p_ts_packet->i_payload_start+14], p_ts_packet->buffer[p_ts_packet->i_payload_start+15], p_ts_packet->buffer[p_ts_packet->i_payload_start+16], p_ts_packet->buffer[p_ts_packet->i_payload_start+17], p_ts_packet->buffer[p_ts_packet->i_payload_start+18], p_ts_packet->buffer[p_ts_packet->i_payload_start+19], p_ts_packet->buffer[p_ts_packet->i_payload_start+20], b_unit_start);
1318
1319
1320     /* Try to find the beginning of the payload in the packet to initialise
1321        the do-while loop that follows -> Compute the i_data_offset variable:
1322        by default, the value is set so that we won't enter in the while loop.
1323        It will be set to a correct value if the data are not corrupted */
1324     i_data_offset = TS_PACKET_SIZE;
1325
1326     /* Has the reassembly of a section already began in a previous packet ? */
1327     if( p_psi->b_running_section )
1328     {
1329         /* Was data lost since the last TS packet ? */
1330         if( b_packet_lost )
1331         {
1332             /* Discard the packet and wait for the begining of a new one to resynch */
1333             p_psi->b_running_section = 0;
1334             p_psi->i_current_position = 0;
1335             intf_DbgMsg( "PSI section(s) discarded due to packet loss\n" );
1336         }
1337         else
1338         {
1339             /* The data that complete a previously began section are always at
1340                the beginning of the TS payload... */
1341             i_data_offset = p_ts_packet->i_payload_start;
1342             /* ...Unless there is a pointer field, that we have to bypass */
1343             if( b_unit_start )
1344                 i_data_offset++;
1345             //intf_DbgMsg( "New part of the section received at offset %d\n", i_data_offset );
1346         }
1347     }
1348     /* We are looking for the beginning of a new section */
1349     else
1350     {
1351         if( b_unit_start )
1352         {
1353             /* Get the offset at which the data for that section can be found
1354                The offset is stored in the pointer_field since we are interested in
1355                the first section of the TS packet. Note that the +1 is to bypass
1356                the pointer field */
1357             i_data_offset = p_ts_packet->i_payload_start +
1358                             p_ts_packet->buffer[p_ts_packet->i_payload_start] + 1;
1359             //intf_DbgMsg( "New section beginning at offset %d in TS packet\n", i_data_offset );
1360         }
1361         else
1362         {
1363             /* This may either mean that the TS is bad or that the packet contains
1364                the end of a section that had been discarded in a previous loop:
1365                trash the TS packet since we cannot do anything with those data: */
1366             p_psi->b_running_section = 0;
1367             p_psi->i_current_position = 0;
1368             intf_DbgMsg( "PSI packet discarded due to lack of synchronisation\n" );
1369         }
1370     }
1371
1372     /* The section we will deal with during the first iteration of the following
1373        loop is the first one contained in the TS packet */
1374     //    b_first_section = 1;
1375
1376     /* Reassemble the pieces of sections contained in the TS packet and decode
1377        the sections that could have been completed.
1378        Stop when we reach the end of the packet or stuffing bytes */
1379     while( i_data_offset < TS_PACKET_SIZE && p_ts_packet->buffer[i_data_offset] != 0xFF )
1380     {
1381         /* If the current section is a new one, reinit the data fields of the p_psi
1382            struct to start its decoding */
1383         if( !p_psi->b_running_section )
1384         {
1385             /* Read the length of the new section */
1386             p_psi->i_length = (U16_AT(&p_ts_packet->buffer[i_data_offset+1]) & 0xFFF) + 3;
1387             //intf_DbgMsg( "Section length %d\n", p_psi->i_length );
1388             if( p_psi->i_length > PSI_SECTION_SIZE )
1389             {
1390                 /* The TS packet is corrupted, stop here to avoid possible a seg fault */
1391                 intf_DbgMsg( "PSI Section size is too big, aborting its reception\n" );
1392                 break;
1393             }
1394
1395             /* Init the reassembly of that section */
1396             p_psi->b_running_section = 1;
1397             p_psi->i_current_position = 0;
1398         }
1399
1400       /* Compute the length of data related to the section in this TS packet */
1401         if( p_psi->i_length - p_psi->i_current_position > TS_PACKET_SIZE - i_data_offset)
1402             i_data_length = TS_PACKET_SIZE - i_data_offset;
1403         else
1404           i_data_length = p_psi->i_length - p_psi->i_current_position;
1405
1406         /* Copy those data in the section buffer */
1407         memcpy( &p_psi->buffer[p_psi->i_current_position], &p_ts_packet->buffer[i_data_offset],
1408                 i_data_length );
1409
1410         /* Interesting data are now after the ones we copied, since no gap is
1411            allowed between 2 sections in a TS packets */
1412         i_data_offset += i_data_length;
1413
1414         /* Decode the packet if it is now complete */
1415         if (p_psi->i_length == p_psi->i_current_position + i_data_length)
1416         {
1417             /* Packet is complete, decode it */
1418             //intf_DbgMsg( "SECTION COMPLETE: starting decoding of its data\n" );
1419             input_PsiDecode( p_input, p_psi );
1420
1421             /* Prepare the buffer to receive a new section */
1422             p_psi->i_current_position = 0;
1423             p_psi->b_running_section = 0;
1424
1425             /* The new section won't be the first anymore */
1426             //b_first_section = 0;
1427         }
1428         else
1429         {
1430             /* Prepare the buffer to receive the next part of the section */
1431           p_psi->i_current_position += i_data_length;
1432           //intf_DbgMsg( "Section not complete, waiting for the end\n" );
1433         }
1434
1435         //intf_DbgMsg( "Must loop ? Next data offset: %d, stuffing: %d\n",
1436         //             i_data_offset, p_ts_packet->buffer[i_data_offset] );
1437     }
1438
1439     /* Relase the TS packet, we don't need it anymore */
1440     input_NetlistFreeTS( p_input, p_ts_packet );
1441
1442 #undef p_psi
1443 }