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