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