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

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