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