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