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