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