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>
  13 #include <sys/uio.h>
  14 #include <string.h>
  15
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <sys/ioctl.h>
  19 #include <net/if.h>
  20 #include <netinet/in.h>
  21
  22 #include "common.h"
  23 #include "config.h"
  24 #include "mtime.h"
  25 #include "vlc_thread.h"
  26 #include "intf_msg.h"
  27 #include "debug.h"
  28
  29 #include "input.h"
  30 #include "input_psi.h"
  31 #include "input_pcr.h"
  32 #include "input_netlist.h"
  33 #include "decoder_fifo.h"
  34 #include "input_file.h"
  35 #include "input_network.h"
  36
  37 #include "audio_output.h"
  38 #include "audio_decoder.h"
  39
  40 #include "video.h"
  41 #include "video_output.h"
  42 #include "vdec_idct.h"
  43 #include "vdec_motion.h"
  44 #include "video_decoder.h"
  45 #include "vpar_blocks.h"
  46 #include "vpar_headers.h"
  47 #include "vpar_synchro.h"
  48 #include "video_parser.h"
  49
  50 #include "ac3_decoder.h"
  51 #include "ac3_decoder_thread.h"
  52 #include "spu_decoder.h"
  53
  54 #include "main.h"
  55
  56 /*****************************************************************************
  57  * Local prototypes
  58  *****************************************************************************/
  59 static void RunThread   ( input_thread_t *p_input );
  60 static void ErrorThread ( input_thread_t *p_input );
  61 static void EndThread   ( input_thread_t *p_input );
  62
  63 static __inline__ int   input_ReadPacket( input_thread_t *p_input );
  64 static __inline__ void  input_SortPacket( input_thread_t *p_input,
  65                                           ts_packet_t *ts_packet );
  66 static __inline__ void  input_DemuxTS( input_thread_t *p_input,
  67                                        ts_packet_t *ts_packet,
  68                                        es_descriptor_t *es_descriptor );
  69 static __inline__ void  input_DemuxPES( input_thread_t *p_input,
  70                                         ts_packet_t *ts_packet,
  71                                         es_descriptor_t *p_es_descriptor,
  72                                         boolean_t b_unit_start, boolean_t b_packet_lost );
  73 static __inline__ void  input_DemuxPSI( input_thread_t *p_input,
  74                                         ts_packet_t *ts_packet,
  75                                         es_descriptor_t *p_es_descriptor,
  76                                         boolean_t b_unit_start, boolean_t b_packet_lost );
  77
  78 /*****************************************************************************
  79  * input_CreateThread: creates a new input thread
  80  *****************************************************************************
  81  * This function creates a new input, and returns a pointer
  82  * to its description. On error, it returns NULL.
  83  * If pi_status is NULL, then the function will block until the thread is ready.
  84  * If not, it will be updated using one of the THREAD_* constants.
  85  *****************************************************************************/
  86 input_thread_t *input_CreateThread ( int i_method, char *psz_source, int i_port, int i_vlan,
  87                                      p_vout_thread_t p_vout, p_aout_thread_t p_aout, int *pi_status )
  88 {
  89     input_thread_t *    p_input;                        /* thread descriptor */
  90     int                 i_status;                           /* thread status */
  91     int                 i_index;          /* index for tables initialization */
  92
  93     /* Allocate descriptor */
  94     intf_DbgMsg("\n");
  95     p_input = (input_thread_t *)malloc( sizeof(input_thread_t) );
  96     if( p_input == NULL )
  97     {
  98         intf_ErrMsg("error: %s\n", strerror(ENOMEM));
  99         return( NULL );
 100     }
 101
 102     /* Initialize thread properties */
 103     p_input->b_die              = 0;
 104     p_input->b_error            = 0;
 105     p_input->pi_status          = (pi_status != NULL) ? pi_status : &i_status;
 106     *p_input->pi_status         = THREAD_CREATE;
 107
 108     /* Initialize input method description */
 109     p_input->i_method           = i_method;
 110     p_input->psz_source         = psz_source;
 111     p_input->i_port             = i_port;
 112     p_input->i_vlan             = i_vlan;
 113     switch( i_method )
 114     {
 115     case INPUT_METHOD_TS_FILE:                               /* file methods */
 116         p_input->p_Open =   input_FileOpen;
 117         p_input->p_Read =   input_FileRead;
 118         p_input->p_Close =  input_FileClose;
 119         break;
 120     case INPUT_METHOD_TS_VLAN_BCAST:                  /* vlan network method */
 121         if( !p_main->b_vlans )
 122         {
 123             intf_ErrMsg("error: vlans are not activated\n");
 124             free( p_input );
 125             return( NULL );
 126         }
 127         /* ... pass through */
 128     case INPUT_METHOD_TS_UCAST:                           /* network methods */
 129     case INPUT_METHOD_TS_MCAST:
 130     case INPUT_METHOD_TS_BCAST:
 131         p_input->p_Open =   input_NetworkOpen;
 132         p_input->p_Read =   input_NetworkRead;
 133         p_input->p_Close =  input_NetworkClose;
 134         break;
 135     default:
 136         intf_ErrMsg("error: unknow input method\n");
 137         free( p_input );
 138         return( NULL );
 139         break;
 140     }
 141
 142     /* Initialize stream description */
 143     for( i_index = 0; i_index < INPUT_MAX_ES; i_index++ )
 144     {
 145         p_input->p_es[i_index].i_id = EMPTY_PID;
 146         p_input->pp_selected_es[i_index] = NULL;
 147     }
 148
 149     /* Initialize default settings for spawned decoders */
 150     p_input->p_aout                     = p_aout;
 151     p_input->p_vout                     = p_vout;
 152
 153 #ifdef STATS
 154     /* Initialize statistics */
 155     p_input->c_loops                    = 0;
 156     p_input->c_bytes                    = 0;
 157     p_input->c_payload_bytes            = 0;
 158     p_input->c_packets_read             = 0;
 159     p_input->c_packets_trashed          = 0;
 160 #endif
 161
 162     /* Initialize PSI and PCR decoders */
 163     if( input_PsiInit( p_input ) )
 164     {
 165         free( p_input );
 166         return( NULL );
 167     }
 168
 169     if( input_PcrInit( p_input ) )
 170     {
 171         input_PsiEnd( p_input );
 172         free( p_input );
 173         return( NULL );
 174     }
 175
 176     /* Initialize netlists */
 177     if( input_NetlistInit( p_input ) )
 178     {
 179         input_PsiEnd( p_input );
 180         input_PcrEnd( p_input );
 181         free( p_input );
 182         return( NULL );
 183     }
 184
 185     intf_DbgMsg("configuration: method=%d, source=%s, port=%d, vlan=%d\n",
 186                 i_method, psz_source, i_port, i_vlan );
 187
 188     /* Let the appropriate method open the socket. */
 189     if( p_input->p_Open( p_input ) )
 190     {
 191         input_NetlistEnd( p_input );
 192         input_PsiEnd( p_input );
 193         input_PcrEnd( p_input );
 194         free( p_input );
 195         return( NULL );
 196     }
 197
 198     /* Create thread and set locks. */
 199     vlc_mutex_init( &p_input->netlist.lock );
 200     vlc_mutex_init( &p_input->programs_lock );
 201     vlc_mutex_init( &p_input->es_lock );
 202     if( vlc_thread_create(&p_input->thread_id, "input", (void *) RunThread, (void *) p_input) )
 203     {
 204         intf_ErrMsg("error: %s\n", strerror(errno) );
 205         p_input->p_Close( p_input );
 206         input_NetlistEnd( p_input );;
 207         input_PsiEnd( p_input );
 208         input_PcrEnd( p_input );
 209         free( p_input );
 210         return( NULL );
 211     }
 212
 213     intf_Msg("Input initialized\n");
 214
 215     /* If status is NULL, wait until the thread is created */
 216     if( pi_status == NULL )
 217     {
 218         do
 219         {
 220             msleep( THREAD_SLEEP );
 221         }while( (i_status != THREAD_READY) && (i_status != THREAD_ERROR)
 222                 && (i_status != THREAD_FATAL) );
 223         if( i_status != THREAD_READY )
 224         {
 225             return( NULL );
 226         }
 227     }
 228     return( p_input );
 229 }
 230
 231 /*****************************************************************************
 232  * input_DestroyThread: mark an input thread as zombie
 233  *****************************************************************************
 234  * This function should not return until the thread is effectively cancelled.
 235  *****************************************************************************/
 236 void input_DestroyThread( input_thread_t *p_input, int *pi_status )
 237 {
 238     int         i_status;                                   /* thread status */
 239
 240     /* Set status */
 241     p_input->pi_status = (pi_status != NULL) ? pi_status : &i_status;
 242     *p_input->pi_status = THREAD_DESTROY;
 243
 244     /* Request thread destruction */
 245     p_input->b_die = 1;
 246
 247     /* If status is NULL, wait until thread has been destroyed */
 248     if( pi_status == NULL )
 249     {
 250         do
 251         {
 252             msleep( THREAD_SLEEP );
 253         }while( (i_status != THREAD_OVER) && (i_status != THREAD_ERROR)
 254                 && (i_status != THREAD_FATAL) );
 255     }
 256 }
 257
 258 #if 0
 259 /*****************************************************************************
 260  * input_OpenAudioStream: open an audio stream
 261  *****************************************************************************
 262  * This function spawns an audio decoder and plugs it on the audio output
 263  * thread.
 264  *****************************************************************************/
 265 int input_OpenAudioStream( input_thread_t *p_input, int i_id )
 266 {
 267     /* ?? */
 268 }
 269
 270 /*****************************************************************************
 271  * input_CloseAudioStream: close an audio stream
 272  *****************************************************************************
 273  * This function destroys an audio decoder.
 274  *****************************************************************************/
 275 void input_CloseAudioStream( input_thread_t *p_input, int i_id )
 276 {
 277     /* ?? */
 278 }
 279
 280 /*****************************************************************************
 281  * input_OpenVideoStream: open a video stream
 282  *****************************************************************************
 283  * This function spawns a video decoder and plugs it on a video output thread.
 284  *****************************************************************************/
 285 int input_OpenVideoStream( input_thread_t *p_input,
 286                            struct vout_thread_s *p_vout, struct video_cfg_s * p_cfg )
 287 {
 288     /* ?? */
 289 }
 290
 291 /*****************************************************************************
 292  * input_CloseVideoStream: close a video stream
 293  *****************************************************************************
 294  * This function destroys an video decoder.
 295  *****************************************************************************/
 296 void input_CloseVideoStream( input_thread_t *p_input, int i_id )
 297 {
 298     /* ?? */
 299 }
 300 #endif
 301
 302 /* following functions are local */
 303
 304 /*****************************************************************************
 305  * InitThread: initialize input thread
 306  *****************************************************************************
 307  * This function is called from RunThread and performs the second step of the
 308  * initialization. It returns 0 on success. Note that the thread's flag are not
 309  * modified inside this function.
 310  *****************************************************************************/
 311 static int InitThread( input_thread_t *p_input )
 312 {
 313     /* Mark thread as running and return */
 314     intf_DbgMsg("\n");
 315     *p_input->pi_status =        THREAD_READY;
 316     intf_DbgMsg("thread ready\n");
 317     return( 0 );
 318 }
 319
 320 /*****************************************************************************
 321  * RunThread: main thread loop
 322  *****************************************************************************
 323  * Thread in charge of processing the network packets and demultiplexing.
 324  *****************************************************************************/
 325 static void RunThread( input_thread_t *p_input )
 326 {
 327     /*
 328      * Initialize thread and free configuration
 329      */
 330     p_input->b_error = InitThread( p_input );
 331     if( p_input->b_error )
 332     {
 333         free( p_input );                               /* destroy descriptor */
 334         return;
 335     }
 336
 337     /*
 338      * Main loop
 339      */
 340     intf_DbgMsg("\n");
 341     while( !p_input->b_die && !p_input->b_error )
 342     {
 343         /* Scatter read the UDP packet from the network or the file. */
 344         if( (input_ReadPacket( p_input )) == (-1) )
 345         {
 346             /* ??? Normally, a thread can't kill itself, but we don't have
 347              * any method in case of an error condition ... */
 348             p_input->b_error = 1;
 349         }
 350
 351 #ifdef STATS
 352         p_input->c_loops++;
 353 #endif
 354     }
 355
 356     /*
 357      * Error loop
 358      */
 359     if( p_input->b_error )
 360     {
 361         ErrorThread( p_input );
 362     }
 363
 364     /* End of thread */
 365     EndThread( p_input );
 366     intf_DbgMsg("thread end\n");
 367 }
 368
 369
 370 /*****************************************************************************
 371  * ErrorThread: RunThread() error loop
 372  *****************************************************************************
 373  * This function is called when an error occured during thread main's loop.
 374  *****************************************************************************/
 375 static void ErrorThread( input_thread_t *p_input )
 376 {
 377     /* Wait until a `die' order */
 378     intf_DbgMsg("\n");
 379     while( !p_input->b_die )
 380     {
 381         /* Sleep a while */
 382         msleep( VOUT_IDLE_SLEEP );
 383     }
 384 }
 385
 386 /*****************************************************************************
 387  * EndThread: end the input thread
 388  *****************************************************************************/
 389 static void EndThread( input_thread_t * p_input )
 390 {
 391     int *       pi_status;                                  /* threas status */
 392     int         i_es_loop;                                       /* es index */
 393
 394     /* Store status */
 395     intf_DbgMsg("\n");
 396     pi_status = p_input->pi_status;
 397     *pi_status = THREAD_END;
 398
 399     /* Close input method */
 400     p_input->p_Close( p_input );
 401
 402     /* Destroy all decoder threads */
 403     for( i_es_loop = 0;
 404          (i_es_loop < INPUT_MAX_ES) && (p_input->pp_selected_es[i_es_loop] != NULL) ;
 405          i_es_loop++ )
 406     {
 407         switch( p_input->pp_selected_es[i_es_loop]->i_type )
 408         {
 409         case MPEG1_VIDEO_ES:
 410         case MPEG2_VIDEO_ES:
 411 #ifdef OLD_DECODER
 412             vdec_DestroyThread( (vdec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
 413 #else
 414             vpar_DestroyThread( (vpar_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
 415 #endif
 416             break;
 417         case MPEG1_AUDIO_ES:
 418         case MPEG2_AUDIO_ES:
 419             adec_DestroyThread( (adec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 420             break;
 421         case AC3_AUDIO_ES:
 422             ac3dec_DestroyThread( (ac3dec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 423             break;
 424         case DVD_SPU_ES:
 425             spudec_DestroyThread( (spudec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
 426             break;
 427         case 0:
 428             /* Special streams for the PSI decoder, PID 0 and 1 */
 429             break;
 430 #ifdef DEBUG
 431         default:
 432             intf_DbgMsg("error: unknown decoder type %d\n", p_input->pp_selected_es[i_es_loop]->i_type );
 433             break;
 434 #endif
 435         }
 436     }
 437
 438     input_NetlistEnd( p_input );                            /* clean netlist */
 439     input_PsiEnd( p_input );                        /* clean PSI information */
 440     input_PcrEnd( p_input );                        /* clean PCR information */
 441     free( p_input );                          /* free input_thread structure */
 442
 443     /* Update status */
 444     *pi_status = THREAD_OVER;
 445 }
 446
 447 /*****************************************************************************
 448  * input_ReadPacket: reads a packet from the network or the file
 449  *****************************************************************************/
 450 static __inline__ int input_ReadPacket( input_thread_t *p_input )
 451 {
 452     int                 i_base_index; /* index of the first free iovec */
 453     int                 i_current_index;
 454     int                 i_packet_size;
 455 #ifdef INPUT_LIFO_TS_NETLIST
 456     int                 i_meanwhile_released;
 457     int                 i_currently_removed;
 458 #endif
 459     ts_packet_t *       p_ts_packet;
 460
 461     /* In this function, we only care about the TS netlist. PES netlist
 462      * is for the demultiplexer. */
 463 #ifdef INPUT_LIFO_TS_NETLIST
 464     i_base_index = p_input->netlist.i_ts_index;
 465
 466     /* Verify that we still have packets in the TS netlist */
 467     if( (INPUT_MAX_TS + INPUT_TS_READ_ONCE - 1 - p_input->netlist.i_ts_index) <= INPUT_TS_READ_ONCE )
 468     {
 469         intf_ErrMsg("input error: TS netlist is empty !\n");
 470         return( -1 );
 471     }
 472
 473 #else /* FIFO netlist */
 474     i_base_index = p_input->netlist.i_ts_start;
 475     if( p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE -1 > INPUT_MAX_TS )
 476     {
 477         /* The netlist is splitted in 2 parts. We must gather them to consolidate
 478            the FIFO (we make the loop easily in having the same iovec at the far
 479            end and in the beginning of netlist_free).
 480            That's why the netlist is (INPUT_MAX_TS +1) + (INPUT_TS_READ_ONCE -1)
 481            large. */
 482         memcpy( p_input->netlist.p_ts_free + INPUT_MAX_TS + 1,
 483                 p_input->netlist.p_ts_free,
 484                 (p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE - 1 - INPUT_MAX_TS)
 485                   * sizeof(struct iovec) );
 486     }
 487
 488     /* Verify that we still have packets in the TS netlist */
 489     if( ((p_input->netlist.i_ts_end -1 - p_input->netlist.i_ts_start) & INPUT_MAX_TS) <= INPUT_TS_READ_ONCE )
 490     {
 491         intf_ErrMsg("input error: TS netlist is empty !\n");
 492         return( -1 );
 493     }
 494 #endif /* FIFO netlist */
 495
 496     /* Scatter read the buffer. */
 497     i_packet_size = (*p_input->p_Read)( p_input,
 498                            &p_input->netlist.p_ts_free[i_base_index],
 499                            INPUT_TS_READ_ONCE );
 500     if( i_packet_size == (-1) )
 501     {
 502 //      intf_DbgMsg("Read packet %d %p %d %d\n", i_base_index,
 503 //                      &p_input->netlist.p_ts_free[i_base_index],
 504 //                      p_input->netlist.i_ts_start,
 505 //                      p_input->netlist.i_ts_end);
 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 ?? */
 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 ?? */
 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                     /* we skip 4 bytes at the beginning of the AC3 payload */
1076                     p_ts->i_payload_start += 4;
1077                     p_fifo = &(((ac3dec_thread_t *)(p_es_descriptor->p_dec))->fifo);
1078                     break;
1079
1080                 case DVD_SPU_ES:
1081                     /* we skip 4 bytes at the beginning of the subpicture payload */
1082                     p_ts->i_payload_start += 4;
1083                     p_fifo = &(((spudec_thread_t *)(p_es_descriptor->p_dec))->fifo);
1084                     break;
1085
1086                 default:
1087                     /* This should never happen */
1088                     intf_DbgMsg("Unknown stream type (%d, %d): PES trashed\n",
1089                         p_es_descriptor->i_id, p_es_descriptor->i_type);
1090                     p_fifo = NULL;
1091                     break;
1092             }
1093
1094             if( p_fifo != NULL )
1095             {
1096                 vlc_mutex_lock( &p_fifo->data_lock );
1097                 if( DECODER_FIFO_ISFULL( *p_fifo ) )
1098                 {
1099                     /* The FIFO is full !!! This should not happen. */
1100 #ifdef STATS
1101                     p_input->c_packets_trashed += p_pes->i_ts_packets;
1102                     p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
1103 #endif
1104                     input_NetlistFreePES( p_input, p_pes );
1105                     intf_DbgMsg("PES trashed - fifo full ! (%d, %d)\n",
1106                                p_es_descriptor->i_id, p_es_descriptor->i_type);
1107                 }
1108                 else
1109                 {
1110 //                    intf_DbgMsg("Putting %p into fifo %p/%d\n",
1111 //                                p_pes, p_fifo, p_fifo->i_end);
1112                     p_fifo->buffer[p_fifo->i_end] = p_pes;
1113                     DECODER_FIFO_INCEND( *p_fifo );
1114
1115                     /* Warn the decoder that it's got work to do. */
1116                     vlc_cond_signal( &p_fifo->data_wait );
1117                 }
1118                 vlc_mutex_unlock( &p_fifo->data_lock );
1119             }
1120             else
1121             {
1122                 intf_DbgMsg("No fifo to receive PES %p: trash\n", p_pes);
1123 #ifdef STATS
1124                 p_input->c_packets_trashed += p_pes->i_ts_packets;
1125                 p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
1126 #endif
1127                 input_NetlistFreePES( p_input, p_pes );
1128             }
1129         }
1130     }
1131
1132
1133     /* If we are at the beginning of a new PES packet, we must fetch a new
1134        PES buffer to begin with the reassembly of this PES packet. This is
1135        also here that we can synchronise with the stream if we we lost
1136        packets or if the decoder has just started */
1137     if( b_unit_start )
1138     {
1139         p_last_pes = p_pes;
1140
1141         /* Get a new one PES from the PES netlist. */
1142         if( (p_pes = input_NetlistGetPES( p_input )) == (NULL) )
1143         {
1144             /* PES netlist is empty ! */
1145             p_input->b_error = 1;
1146         }
1147         else
1148         {
1149 //           intf_DbgMsg("New PES packet %p (first TS: %p)\n", p_pes, p_ts_packet);
1150
1151             /* Init the PES fields so that the first TS packet could be correctly
1152                added to the PES packet (see below) */
1153             p_pes->p_first_ts = p_ts_packet;
1154             p_pes->p_last_ts = NULL;
1155
1156             /* If the last pes packet was null, this means that the synchronisation
1157                was lost and so warn the decoder that he will have to find a way to
1158                recover */
1159             if( !p_last_pes )
1160                 p_pes->b_data_loss = 1;
1161
1162             /* Read the b_random_access flag status and then reinit it */
1163             p_pes->b_random_access = p_es_descriptor->b_random;
1164             p_es_descriptor->b_random = 0;
1165         }
1166     }
1167
1168
1169     /* If we are synchronised with the stream, and so if we are ready to
1170        receive correctly the data, add the TS packet to the current PES
1171        packet */
1172     if( p_pes != NULL )
1173     {
1174 //      intf_DbgMsg("Adding TS %p to PES %p\n", p_ts_packet, p_pes);
1175
1176         /* Size of the payload carried in the TS packet */
1177         i_ts_payload_size = p_ts_packet->i_payload_end -
1178                             p_ts_packet->i_payload_start;
1179
1180         /* Update the relations between the TS packets */
1181         p_ts_packet->p_prev_ts = p_pes->p_last_ts;
1182         p_ts_packet->p_next_ts = NULL;
1183         if( p_pes->i_ts_packets != 0 )
1184         {
1185             /* Regarder si il serait pas plus efficace de ne creer que les liens
1186                precedent->suivant pour le moment, et les liens suivant->precedent
1187                quand le paquet est termine */
1188             /* Otherwise it is the first TS packet. */
1189             p_pes->p_last_ts->p_next_ts = p_ts_packet;
1190         }
1191         /* Now add the TS to the PES packet */
1192         p_pes->p_last_ts = p_ts_packet;
1193         p_pes->i_ts_packets++;
1194         p_pes->i_pes_size += i_ts_payload_size;
1195
1196         /* Stats */
1197 #ifdef STATS
1198         i_dummy = p_ts_packet->i_payload_end - p_ts_packet->i_payload_start;
1199         p_es_descriptor->c_payload_bytes += i_dummy;
1200 #endif
1201     }
1202     else
1203     {
1204         /* Since we don't use the TS packet to build a PES packet, we don't
1205            need it anymore, so give it back to the netlist */
1206 //        intf_DbgMsg("Trashing TS %p: no PES being build\n", p_ts_packet);
1207         input_NetlistFreeTS( p_input, p_ts_packet );
1208     }
1209
1210 #undef p_pes
1211 }
1212
1213
1214
1215
1216 /*****************************************************************************
1217  * input_DemuxPSI:
1218  *****************************************************************************
1219  * Notice that current ES state has been locked by input_SortPacket. (No more true,
1220  * changed by benny - See if it's ok, and definitely change the code ???????? )
1221  *****************************************************************************/
1222 static __inline__ void input_DemuxPSI( input_thread_t *p_input,
1223                                        ts_packet_t *p_ts_packet,
1224                                        es_descriptor_t *p_es_descriptor,
1225                                        boolean_t b_unit_start, boolean_t b_packet_lost )
1226 {
1227     int i_data_offset;    /* Offset of the interesting data in the TS packet */
1228     u16 i_data_length;                               /* Length of those data */
1229     //boolean_t b_first_section; /* Was there another section in the TS packet ? */
1230
1231     ASSERT(p_input);
1232     ASSERT(p_ts_packet);
1233     ASSERT(p_es_descriptor);
1234
1235 #define p_psi (p_es_descriptor->p_psi_section)
1236
1237 //    intf_DbgMsg( "input debug: PSI demultiplexing %p (%p)\n", p_ts_packet, p_input);
1238
1239 //    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);
1240
1241
1242     /* Try to find the beginning of the payload in the packet to initialise
1243        the do-while loop that follows -> Compute the i_data_offset variable:
1244        by default, the value is set so that we won't enter in the while loop.
1245        It will be set to a correct value if the data are not corrupted */
1246     i_data_offset = TS_PACKET_SIZE;
1247
1248     /* Has the reassembly of a section already began in a previous packet ? */
1249     if( p_psi->b_running_section )
1250     {
1251         /* Was data lost since the last TS packet ? */
1252         if( b_packet_lost )
1253         {
1254             /* Discard the packet and wait for the begining of a new one to resynch */
1255             p_psi->b_running_section = 0;
1256             p_psi->i_current_position = 0;
1257             intf_DbgMsg( "PSI section(s) discarded due to packet loss\n" );
1258         }
1259         else
1260         {
1261             /* The data that complete a previously began section are always at
1262                the beginning of the TS payload... */
1263             i_data_offset = p_ts_packet->i_payload_start;
1264             /* ...Unless there is a pointer field, that we have to bypass */
1265             if( b_unit_start )
1266                 i_data_offset++;
1267 //            intf_DbgMsg( "New part of the section received at offset %d\n", i_data_offset );
1268         }
1269     }
1270     /* We are looking for the beginning of a new section */
1271     else
1272     {
1273         if( b_unit_start )
1274         {
1275             /* Get the offset at which the data for that section can be found
1276                The offset is stored in the pointer_field since we are interested in
1277                the first section of the TS packet. Note that the +1 is to bypass
1278                the pointer field */
1279             i_data_offset = p_ts_packet->i_payload_start +
1280                             p_ts_packet->buffer[p_ts_packet->i_payload_start] + 1;
1281 //            intf_DbgMsg( "New section beginning at offset %d in TS packet\n", i_data_offset );
1282         }
1283         else
1284         {
1285             /* This may either mean that the TS is bad or that the packet contains
1286                the end of a section that had been discarded in a previous loop:
1287                trash the TS packet since we cannot do anything with those data: */
1288             p_psi->b_running_section = 0;
1289             p_psi->i_current_position = 0;
1290             intf_DbgMsg( "PSI packet discarded due to lack of synchronisation\n" );
1291         }
1292     }
1293
1294     /* The section we will deal with during the first iteration of the following
1295        loop is the first one contained in the TS packet */
1296     //    b_first_section = 1;
1297
1298     /* Reassemble the pieces of sections contained in the TS packet and decode
1299        the sections that could have been completed.
1300        Stop when we reach the end of the packet or stuffing bytes */
1301     while( i_data_offset < TS_PACKET_SIZE && p_ts_packet->buffer[i_data_offset] != 0xFF )
1302     {
1303         /* If the current section is a new one, reinit the data fields of the p_psi
1304            struct to start its decoding */
1305         if( !p_psi->b_running_section )
1306         {
1307             /* Read the length of the new section */
1308             p_psi->i_length = (U16_AT(&p_ts_packet->buffer[i_data_offset+1]) & 0xFFF) + 3;
1309 //            intf_DbgMsg( "Section length %d\n", p_psi->i_length );
1310             if( p_psi->i_length > PSI_SECTION_SIZE )
1311             {
1312                 /* The TS packet is corrupted, stop here to avoid possible a seg fault */
1313                 intf_DbgMsg( "PSI Section size is too big, aborting its reception\n" );
1314                 break;
1315             }
1316
1317             /* Init the reassembly of that section */
1318             p_psi->b_running_section = 1;
1319             p_psi->i_current_position = 0;
1320         }
1321
1322       /* Compute the length of data related to the section in this TS packet */
1323         if( p_psi->i_length - p_psi->i_current_position > TS_PACKET_SIZE - i_data_offset)
1324             i_data_length = TS_PACKET_SIZE - i_data_offset;
1325         else
1326           i_data_length = p_psi->i_length - p_psi->i_current_position;
1327
1328         /* Copy those data in the section buffer */
1329         memcpy( &p_psi->buffer[p_psi->i_current_position], &p_ts_packet->buffer[i_data_offset],
1330                 i_data_length );
1331
1332         /* Interesting data are now after the ones we copied, since no gap is
1333            allowed between 2 sections in a TS packets */
1334         i_data_offset += i_data_length;
1335
1336         /* Decode the packet if it is now complete */
1337         if (p_psi->i_length == p_psi->i_current_position + i_data_length)
1338         {
1339             /* Packet is complete, decode it */
1340 //            intf_DbgMsg( "SECTION COMPLETE: starting decoding of its data\n" );
1341             input_PsiDecode( p_input, p_psi );
1342
1343             /* Prepare the buffer to receive a new section */
1344             p_psi->i_current_position = 0;
1345             p_psi->b_running_section = 0;
1346
1347             /* The new section won't be the first anymore */
1348             //b_first_section = 0;
1349         }
1350         else
1351         {
1352             /* Prepare the buffer to receive the next part of the section */
1353           p_psi->i_current_position += i_data_length;
1354 //          intf_DbgMsg( "Section not complete, waiting for the end\n" );
1355         }
1356
1357 //        intf_DbgMsg( "Must loop ? Next data offset: %d, stuffing: %d\n",
1358 //                     i_data_offset, p_ts_packet->buffer[i_data_offset] );
1359     }
1360
1361     /* Relase the TS packet, we don't need it anymore */
1362     input_NetlistFreeTS( p_input, p_ts_packet );
1363
1364 #undef p_psi
1365 }