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