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