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