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         p_input->c_payload_bytes += i_dummy;
 909 #endif
 910
 911         /* We can check if the packet is finished */
 912         if( p_pes->i_pes_size == p_pes->i_pes_real_size )
 913         {
 914             /* The packet is finished, parse it */
 915             input_ParsePES( p_input, p_es_descriptor );
 916
 917             /* Tell the Demux we have parsed this PES, no need to redo it */
 918             p_pes = NULL;
 919         }
 920     }
 921     else
 922     {
 923         /* Since we don't use the TS packet to build a PES packet, we don't
 924            need it anymore, so give it back to the netlist */
 925         //intf_DbgMsg("Trashing TS %p: no PES being build\n", p_ts_packet);
 926         input_NetlistFreeTS( p_input, p_ts_packet );
 927     }
 928
 929 #undef p_pes
 930 }
 931
 932 /*****************************************************************************
 933  * input_DemuxTS: first step of demultiplexing: the TS header
 934  *****************************************************************************
 935  * Stream must also only contain PES and PSI, so PID must have been filtered
 936  *****************************************************************************/
 937 static __inline__ void input_DemuxTS( input_thread_t *p_input,
 938                                       ts_packet_t *p_ts_packet,
 939                                       es_descriptor_t *p_es_descriptor )
 940 {
 941     int         i_dummy;
 942     boolean_t   b_adaption;                     /* Adaption field is present */
 943     boolean_t   b_payload;                         /* Packet carries payload */
 944     boolean_t   b_unit_start;          /* A PSI or a PES start in the packet */
 945     boolean_t   b_trash = 0;                 /* Must the packet be trashed ? */
 946     boolean_t   b_lost = 0;                     /* Was there a packet lost ? */
 947
 948     ASSERT(p_input);
 949     ASSERT(p_ts_packet);
 950     ASSERT(p_es_descriptor);
 951
 952 #define p (p_ts_packet->buffer)
 953
 954     //intf_DbgMsg("input debug: TS-demultiplexing packet %p, pid %d, number %d\n",
 955     //            p_ts_packet, U16_AT(&p[1]) & 0x1fff, p[3] & 0x0f);
 956
 957 #ifdef STATS
 958     p_es_descriptor->c_packets++;
 959     p_es_descriptor->c_bytes += TS_PACKET_SIZE;
 960 #endif
 961
 962     /* Extract flags values from TS common header. */
 963     b_unit_start = (p[1] & 0x40);
 964     b_adaption = (p[3] & 0x20);
 965     b_payload = (p[3] & 0x10);
 966
 967     /* Extract adaption field informations if any */
 968     if( !b_adaption )
 969     {
 970         /* We don't have any adaptation_field, so payload start immediately
 971            after the 4 byte TS header */
 972         p_ts_packet->i_payload_start = 4;
 973     }
 974     else
 975     {
 976         /* p[4] is adaptation_field_length minus one */
 977         p_ts_packet->i_payload_start = 5 + p[4];
 978
 979         /* The adaption field can be limited to the adaptation_field_length byte,
 980            so that there is nothing to do: skip this possibility */
 981         if( p[4] )
 982         {
 983             /* If the packet has both adaptation_field and payload, adaptation_field
 984                cannot be more than 182 bytes long; if there is only an
 985                adaptation_field, it must fill the next 183 bytes. */
 986             if( b_payload ? (p[4] > 182) : (p[4] != 183) )
 987             {
 988                 intf_DbgMsg("input debug: invalid TS adaptation field (%p)\n",
 989                             p_ts_packet);
 990 #ifdef STATS
 991                 p_es_descriptor->c_invalid_packets++;
 992 #endif
 993                 b_trash = 1;
 994             }
 995
 996             /* No we are sure that the byte containing flags is present: read it */
 997             else
 998             {
 999                 /* discontinuity_indicator */
1000                 if( p[5] & 0x80 )
1001                 {
1002                     intf_DbgMsg("discontinuity_indicator encountered by TS demux " \
1003                                 "(position read: %d, saved: %d)\n", p[5] & 0x80,
1004                                 p_es_descriptor->i_continuity_counter);
1005
1006                     /* If the PID carries the PCR, there will be a system time-base
1007                        discontinuity. We let the PCR decoder handle that. */
1008                     p_es_descriptor->b_discontinuity = 1;
1009
1010                     /* There also may be a continuity_counter discontinuity:
1011                resynchronise our counter with the one of the stream */
1012                     p_es_descriptor->i_continuity_counter = (p[3] & 0x0f) - 1;
1013                 }
1014
1015                 /* random_access_indicator */
1016                 p_es_descriptor->b_random |= p[5] & 0x40;
1017
1018                 /* If this is a PCR_PID, and this TS packet contains a PCR,
1019            we pass it along to the PCR decoder. */
1020                 if( (p_es_descriptor->b_pcr) && (p[5] & 0x10) )
1021                 {
1022                     /* There should be a PCR field in the packet, check if the
1023                adaption field is long enough to carry it */
1024                     if( p[4] >= 7 )
1025                     {
1026                         /* Call the PCR decoder */
1027                         input_PcrDecode( p_input, p_es_descriptor, &p[6] );
1028                     }
1029                 }
1030             }
1031         }
1032     }
1033
1034     /* Check the continuity of the stream. */
1035     i_dummy = ((p[3] & 0x0f) - p_es_descriptor->i_continuity_counter) & 0x0f;
1036     if( i_dummy == 1 )
1037     {
1038         /* Everything is ok, just increase our counter */
1039         p_es_descriptor->i_continuity_counter++;
1040     }
1041     else
1042     {
1043         if( !b_payload && i_dummy == 0 )
1044         {
1045             /* This is a packet without payload, this is allowed by the draft
1046                As there is nothing interesting in this packet (except PCR that
1047                have already been handled), we can trash the packet. */
1048             intf_DbgMsg("Packet without payload received by TS demux\n");
1049             b_trash = 1;
1050         }
1051         else if( i_dummy <= 0 )
1052         {
1053             /* Duplicate packet: mark it as being to be trashed. */
1054             intf_DbgMsg("Duplicate packet received by TS demux\n");
1055             b_trash = 1;
1056         }
1057         else if( p_es_descriptor->i_continuity_counter == 0xFF )
1058         {
1059             /* This means that the packet is the first one we receive for this
1060                ES since the continuity counter ranges between 0 and 0x0F
1061                excepts when it has been initialized by the input: Init the
1062                counter to the correct value. */
1063             intf_DbgMsg("First packet for PID %d received by TS demux\n",
1064                         p_es_descriptor->i_id);
1065             p_es_descriptor->i_continuity_counter = (p[3] & 0x0f);
1066         }
1067         else
1068         {
1069             /* This can indicate that we missed a packet or that the
1070                continuity_counter wrapped and we received a dup packet: as we
1071                don't know, do as if we missed a packet to be sure to recover
1072                from this situation */
1073             intf_DbgMsg("Packet lost by TS demux: current %d, packet %d\n",
1074                         p_es_descriptor->i_continuity_counter & 0x0f,
1075                         p[3] & 0x0f);
1076             b_lost = 1;
1077             p_es_descriptor->i_continuity_counter = p[3] & 0x0f;
1078         }
1079     }
1080
1081     /* Trash the packet if it has no payload or if it is bad */
1082     if( b_trash )
1083     {
1084         input_NetlistFreeTS( p_input, p_ts_packet );
1085 #ifdef STATS
1086         p_input->c_packets_trashed++;
1087 #endif
1088     }
1089     else
1090     {
1091         if( p_es_descriptor->b_psi )
1092         {
1093             /* The payload contains PSI tables */
1094             input_DemuxPSI( p_input, p_ts_packet, p_es_descriptor,
1095                             b_unit_start, b_lost );
1096         }
1097         else
1098         {
1099             /* The payload carries a PES stream */
1100             input_DemuxPES( p_input, p_ts_packet, p_es_descriptor,
1101                             b_unit_start, b_lost );
1102         }
1103     }
1104
1105 #undef p
1106 }
1107
1108 /*****************************************************************************
1109  * input_SortPacket: find out whether we need that packet
1110  *****************************************************************************/
1111 static __inline__ void input_SortPacket( input_thread_t *p_input,
1112                                          ts_packet_t *p_ts_packet )
1113 {
1114     int             i_current_pid;
1115     int             i_es_loop;
1116
1117     /* Verify that sync_byte, error_indicator and scrambling_control are
1118        what we expected. */
1119     if( !(p_ts_packet->buffer[0] == 0x47) || (p_ts_packet->buffer[1] & 0x80) ||
1120         (p_ts_packet->buffer[3] & 0xc0) )
1121     {
1122         intf_DbgMsg("input debug: invalid TS header (%p)\n", p_ts_packet);
1123     }
1124     else
1125     {
1126         /* Get the PID of the packet. Note that ntohs is needed, for endianness
1127            purposes (see man page). */
1128         i_current_pid = U16_AT(&p_ts_packet->buffer[1]) & 0x1fff;
1129
1130         //intf_DbgMsg("input debug: pid %d received (%p)\n",
1131         //            i_current_pid, p_ts_packet);
1132
1133         /* Lock current ES state. */
1134         vlc_mutex_lock( &p_input->es_lock );
1135
1136     /* Verify that we actually want this PID. */
1137         for( i_es_loop = 0; i_es_loop < INPUT_MAX_SELECTED_ES; i_es_loop++ )
1138         {
1139             if( p_input->pp_selected_es[i_es_loop] != NULL)
1140             {
1141                 if( (*p_input->pp_selected_es[i_es_loop]).i_id
1142                      == i_current_pid )
1143                 {
1144                     /* Don't need the lock anymore, since the value pointed
1145                        out by p_input->pp_selected_es[i_es_loop] can only be
1146                        modified from inside the input_thread (by the PSI
1147                        decoder): interface thread is only allowed to modify
1148                        the pp_selected_es table */
1149                     vlc_mutex_unlock( &p_input->es_lock );
1150
1151                     /* We're interested. Pass it to the demultiplexer. */
1152                     input_DemuxTS( p_input, p_ts_packet,
1153                                    p_input->pp_selected_es[i_es_loop] );
1154                     return;
1155                 }
1156             }
1157             else
1158             {
1159                 /* pp_selected_es should not contain any hole. */
1160                 break;
1161             }
1162         }
1163         vlc_mutex_unlock( &p_input->es_lock );
1164     }
1165
1166     /* We weren't interested in receiving this packet. Give it back to the
1167        netlist. */
1168     //intf_DbgMsg("SortPacket: freeing unwanted TS %p (pid %d)\n", p_ts_packet,
1169     //                 U16_AT(&p_ts_packet->buffer[1]) & 0x1fff);
1170     input_NetlistFreeTS( p_input, p_ts_packet );
1171 #ifdef STATS
1172     p_input->c_packets_trashed++;
1173 #endif
1174 }
1175
1176 /*****************************************************************************
1177  * input_ReadPacket: reads a packet from the network or the file
1178  *****************************************************************************/
1179 static __inline__ int input_ReadPacket( input_thread_t *p_input )
1180 {
1181     int                 i_base_index; /* index of the first free iovec */
1182     int                 i_current_index;
1183     int                 i_packet_size;
1184 #ifdef INPUT_LIFO_TS_NETLIST
1185     int                 i_meanwhile_released;
1186     int                 i_currently_removed;
1187 #endif
1188     ts_packet_t *       p_ts_packet;
1189
1190     /* In this function, we only care about the TS netlist. PES netlist
1191      * is for the demultiplexer. */
1192 #ifdef INPUT_LIFO_TS_NETLIST
1193     i_base_index = p_input->netlist.i_ts_index;
1194
1195     /* Verify that we still have packets in the TS netlist */
1196     if( (INPUT_MAX_TS + INPUT_TS_READ_ONCE - 1 - p_input->netlist.i_ts_index) <= INPUT_TS_READ_ONCE )
1197     {
1198         intf_ErrMsg("input error: TS netlist is empty !\n");
1199         return( -1 );
1200     }
1201
1202 #else /* FIFO netlist */
1203     i_base_index = p_input->netlist.i_ts_start;
1204     if( p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE -1 > INPUT_MAX_TS )
1205     {
1206         /* The netlist is split in 2 parts. We must gather them to consolidate
1207            the FIFO (we make the loop easily in having the same iovec at the far
1208            end and in the beginning of netlist_free).
1209            That's why the netlist is (INPUT_MAX_TS +1) + (INPUT_TS_READ_ONCE -1)
1210            large. */
1211         memcpy( p_input->netlist.p_ts_free + INPUT_MAX_TS + 1,
1212                 p_input->netlist.p_ts_free,
1213                 (p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE - 1 - INPUT_MAX_TS)
1214                   * sizeof(struct iovec) );
1215     }
1216
1217     /* Verify that we still have packets in the TS netlist */
1218     if( ((p_input->netlist.i_ts_end -1 - p_input->netlist.i_ts_start) & INPUT_MAX_TS) <= INPUT_TS_READ_ONCE )
1219     {
1220         intf_ErrMsg("input error: TS netlist is empty !\n");
1221         return( -1 );
1222     }
1223 #endif /* FIFO netlist */
1224
1225     /* Scatter read the buffer. */
1226     i_packet_size = (*p_input->p_Read)( p_input,
1227                            &p_input->netlist.p_ts_free[i_base_index],
1228                            INPUT_TS_READ_ONCE );
1229     if( i_packet_size == (-1) )
1230     {
1231 #if 0
1232         intf_DbgMsg("Read packet %d %p %d %d\n", i_base_index,
1233                     &p_input->netlist.p_ts_free[i_base_index],
1234                     p_input->netlist.i_ts_start,
1235                     p_input->netlist.i_ts_end);
1236 #endif
1237         intf_ErrMsg("input error: readv() failed (%s)\n", strerror(errno));
1238         return( -1 );
1239     }
1240
1241     if( i_packet_size == 0 )
1242     {
1243         /* No packet has been received, so stop here. */
1244         return( 0 );
1245     }
1246
1247     /* Demultiplex the TS packets (1..INPUT_TS_READ_ONCE) received. */
1248     for( i_current_index = i_base_index;
1249          (i_packet_size -= TS_PACKET_SIZE) >= 0;
1250          i_current_index++ )
1251     {
1252         /* BTW, something REALLY bad could happen if we receive packets with
1253            a wrong size. */
1254         p_ts_packet = (ts_packet_t*)(p_input->netlist.p_ts_free[i_current_index].iov_base);
1255         /* Don't cry :-), we are allowed to do that cast, because initially,
1256            our buffer was malloc'ed with sizeof(ts_packet_t) */
1257
1258         /* Find out if we need this packet and demultiplex. */
1259         input_SortPacket( p_input /* for current PIDs and netlist */,
1260                           p_ts_packet);
1261     }
1262
1263     if( i_packet_size > 0 )
1264     {
1265         intf_ErrMsg("input error: wrong size\n");
1266         return( -1 );
1267     }
1268
1269     /* Remove the TS packets we have just filled from the netlist */
1270 #ifdef INPUT_LIFO_TS_NETLIST
1271     /* We need to take a lock here while we're calculating index positions. */
1272     vlc_mutex_lock( &p_input->netlist.lock );
1273
1274     i_meanwhile_released = i_base_index - p_input->netlist.i_ts_index;
1275     if( i_meanwhile_released )
1276     {
1277         /* That's where it becomes funny :-). Since we didn't take locks for
1278            efficiency reasons, other threads (including ourselves, with
1279            input_DemuxPacket) might have released packets to the netlist.
1280            So we have to copy these iovec where they should go.
1281
1282            BTW, that explains why the TS netlist is
1283            (INPUT_MAX_TS +1) + (TS_READ_ONCE -1) large. */
1284
1285         i_currently_removed = i_current_index - i_base_index;
1286         if( i_meanwhile_released < i_currently_removed )
1287         {
1288             /* Copy all iovecs in that case */
1289             memcpy( &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index]
1290                      + i_currently_removed,
1291                     &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
1292                     i_meanwhile_released * sizeof(struct iovec) );
1293         }
1294         else
1295         {
1296             /* We have fewer places than items, so we only move
1297                i_currently_removed of them. */
1298             memcpy( &p_input->netlist.p_ts_free[i_base_index],
1299                     &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
1300                     i_currently_removed * sizeof(struct iovec) );
1301         }
1302
1303         /* Update i_netlist_index with the information gathered above. */
1304         p_input->netlist.i_ts_index += i_currently_removed;
1305     }
1306     else
1307     {
1308         /* Nothing happened. */
1309         p_input->netlist.i_ts_index = i_current_index;
1310     }
1311
1312     vlc_mutex_unlock( &p_input->netlist.lock );
1313
1314 #else /* FIFO netlist */
1315     /* & is modulo ; that's where we make the loop. */
1316     p_input->netlist.i_ts_start = i_current_index & INPUT_MAX_TS;
1317 #endif
1318
1319 #ifdef STATS
1320     p_input->c_packets_read += i_current_index - i_base_index;
1321     p_input->c_bytes += (i_current_index - i_base_index) * TS_PACKET_SIZE;
1322 #endif
1323     return( 0 );
1324 }
1325
1326 /*****************************************************************************
1327  * RunThread: main thread loop
1328  *****************************************************************************
1329  * Thread in charge of processing the network packets and demultiplexing.
1330  *****************************************************************************/
1331 static void RunThread( input_thread_t *p_input )
1332 {
1333     /*
1334      * Initialize thread and free configuration
1335      */
1336     p_input->b_error = InitThread( p_input );
1337     if( p_input->b_error )
1338     {
1339         free( p_input );                               /* destroy descriptor */
1340         return;
1341     }
1342
1343     /*
1344      * Main loop
1345      */
1346     intf_DbgMsg("\n");
1347     while( !p_input->b_die && !p_input->b_error )
1348     {
1349         /* Scatter read the UDP packet from the network or the file. */
1350         if( (input_ReadPacket( p_input )) == (-1) )
1351         {
1352             /* FIXME??: Normally, a thread can't kill itself, but we don't have
1353              * any method in case of an error condition ... */
1354             p_input->b_error = 1;
1355         }
1356
1357 #ifdef STATS
1358         p_input->c_loops++;
1359 #endif
1360     }
1361
1362     /*
1363      * Error loop
1364      */
1365     if( p_input->b_error )
1366     {
1367         ErrorThread( p_input );
1368     }
1369
1370     /* End of thread */
1371     EndThread( p_input );
1372     intf_DbgMsg("thread end\n");
1373 }
1374
1375
1376 /*****************************************************************************
1377  * ErrorThread: RunThread() error loop
1378  *****************************************************************************
1379  * This function is called when an error occured during thread main's loop.
1380  *****************************************************************************/
1381 static void ErrorThread( input_thread_t *p_input )
1382 {
1383     /* Wait until a `die' order */
1384     intf_DbgMsg("\n");
1385     while( !p_input->b_die )
1386     {
1387         /* Sleep a while */
1388         msleep( VOUT_IDLE_SLEEP );
1389     }
1390 }
1391
1392 /*****************************************************************************
1393  * EndThread: end the input thread
1394  *****************************************************************************/
1395 static void EndThread( input_thread_t * p_input )
1396 {
1397     int *       pi_status;                                  /* threas status */
1398     int         i_es_loop;                                       /* es index */
1399
1400     /* Store status */
1401     intf_DbgMsg("\n");
1402     pi_status = p_input->pi_status;
1403     *pi_status = THREAD_END;
1404
1405 #ifdef STATS
1406     intf_Msg("input stats: Done %d loops\n", p_input->c_loops);
1407     intf_Msg("input stats: Read %d bytes (payload : %d)\n", p_input->c_bytes,
1408              p_input->c_payload_bytes);
1409     intf_Msg("input stats: Read %d packets (trashed : %d)\n",
1410              p_input->c_packets_read, p_input->c_packets_trashed);
1411 #endif
1412
1413     /* Close input method */
1414     p_input->p_Close( p_input );
1415
1416     /* Destroy all decoder threads */
1417     for( i_es_loop = 0;
1418          (i_es_loop < INPUT_MAX_ES) && (p_input->pp_selected_es[i_es_loop] != NULL) ;
1419          i_es_loop++ )
1420     {
1421         switch( p_input->pp_selected_es[i_es_loop]->i_type )
1422         {
1423         case MPEG1_VIDEO_ES:
1424         case MPEG2_VIDEO_ES:
1425             vpar_DestroyThread( (vpar_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
1426             break;
1427         case MPEG1_AUDIO_ES:
1428         case MPEG2_AUDIO_ES:
1429             adec_DestroyThread( (adec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1430             break;
1431         case AC3_AUDIO_ES:
1432             ac3dec_DestroyThread( (ac3dec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1433             break;
1434         case LPCM_AUDIO_ES:
1435             lpcmdec_DestroyThread((lpcmdec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1436             break;
1437         case DVD_SPU_ES:
1438             spudec_DestroyThread( (spudec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1439             break;
1440         case 0:
1441             /* Special streams for the PSI decoder, PID 0 and 1 */
1442             break;
1443 #ifdef DEBUG
1444         default:
1445             intf_DbgMsg("error: unknown decoder type %d\n", p_input->pp_selected_es[i_es_loop]->i_type );
1446             break;
1447 #endif
1448         }
1449     }
1450
1451     input_NetlistEnd( p_input );                            /* clean netlist */
1452     input_PsiEnd( p_input );                        /* clean PSI information */
1453     input_PcrEnd( p_input );                        /* clean PCR information */
1454     free( p_input );                          /* free input_thread structure */
1455
1456     /* Update status */
1457     *pi_status = THREAD_OVER;
1458 }
1459