git.sesse.net Git - vlc/blob - src/input/input.c

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