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