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

   1 /*****************************************************************************
   2  * mpeg_system.c: TS, PS and PES management
   3  *****************************************************************************
   4  * Copyright (C) 1998, 1999, 2000 VideoLAN
   5  *
   6  * Authors:
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #include "defs.h"
  27
  28 #include <stdlib.h>
  29 #include <netinet/in.h>
  30
  31 #include "config.h"
  32 #include "common.h"
  33 #include "threads.h"
  34 #include "mtime.h"
  35
  36 #include "intf_msg.h"
  37
  38 #include "stream_control.h"
  39 #include "input_ext-intf.h"
  40 #include "input_ext-dec.h"
  41
  42 #include "input.h"
  43
  44 #include "mpeg_system.h"
  45
  46 /*****************************************************************************
  47  * Local prototypes
  48  *****************************************************************************/
  49
  50
  51 /*
  52  * PES Packet management
  53  */
  54
  55 /*****************************************************************************
  56  * input_DecodePES
  57  *****************************************************************************
  58  * Put a PES in the decoder's fifo.
  59  *****************************************************************************/
  60 void input_DecodePES( input_thread_t * p_input, es_descriptor_t * p_es )
  61 {
  62 #define p_pes (p_es->p_pes)
  63
  64     /* FIXME: since we don't check the type of the stream anymore, we don't
  65      * do the following : p_data->p_payload_start++; for DVD_SPU_ES, and
  66      * DVD SPU support is BROKEN ! */
  67
  68     if( p_es->p_decoder_fifo != NULL )
  69     {
  70         vlc_mutex_lock( &p_es->p_decoder_fifo->data_lock );
  71
  72 #if 0
  73         if( p_input->stream.b_pace_control )
  74         {
  75             /* FIXME : normally we shouldn't need this... */
  76             while( DECODER_FIFO_ISFULL( *p_es->p_decoder_fifo ) )
  77             {
  78                 vlc_mutex_unlock( &p_es->p_decoder_fifo->data_lock );
  79                 msleep( 20000 );
  80                 vlc_mutex_lock( &p_es->p_decoder_fifo->data_lock );
  81             }
  82         }
  83 #endif
  84
  85         if( !DECODER_FIFO_ISFULL( *p_es->p_decoder_fifo ) )
  86         {
  87             //intf_DbgMsg("Putting %p into fifo %p/%d\n",
  88             //            p_pes, p_fifo, p_fifo->i_end);
  89             p_es->p_decoder_fifo->buffer[p_es->p_decoder_fifo->i_end] = p_pes;
  90             DECODER_FIFO_INCEND( *p_es->p_decoder_fifo );
  91
  92             /* Warn the decoder that it's got work to do. */
  93             vlc_cond_signal( &p_es->p_decoder_fifo->data_wait );
  94         }
  95         else
  96         {
  97             /* The FIFO is full !!! This should not happen. */
  98             p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
  99             intf_ErrMsg( "PES trashed - fifo full ! (%d, %d)",
 100                        p_es->i_id, p_es->i_type);
 101         }
 102         vlc_mutex_unlock( &p_es->p_decoder_fifo->data_lock );
 103     }
 104     else
 105     {
 106         intf_ErrMsg("No fifo to receive PES %p (who wrote this damn code ?)",
 107                     p_pes);
 108         p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 109     }
 110     p_pes = NULL;
 111
 112 #undef p_pes
 113 }
 114
 115 /*****************************************************************************
 116  * input_ParsePES
 117  *****************************************************************************
 118  * Parse a finished PES packet and analyze its header.
 119  *****************************************************************************/
 120 #define PES_HEADER_SIZE     14
 121 void input_ParsePES( input_thread_t * p_input, es_descriptor_t * p_es )
 122 {
 123     data_packet_t * p_header_data;
 124     byte_t          p_header[PES_HEADER_SIZE];
 125     int             i_done, i_todo;
 126
 127 #define p_pes (p_es->p_pes)
 128
 129     //intf_DbgMsg("End of PES packet %p\n", p_pes);
 130
 131     /* Parse the header. The header has a variable length, but in order
 132      * to improve the algorithm, we will read the 14 bytes we may be
 133      * interested in */
 134     p_header_data = p_pes->p_first;
 135     i_done = 0;
 136
 137     for( ; ; )
 138     {
 139         i_todo = p_header_data->p_payload_end
 140                      - p_header_data->p_payload_start;
 141         if( i_todo > PES_HEADER_SIZE - i_done )
 142             i_todo = PES_HEADER_SIZE - i_done;
 143
 144         memcpy( p_header + i_done, p_header_data->p_payload_start,
 145                 i_todo );
 146         i_done += i_todo;
 147
 148         if( i_done < PES_HEADER_SIZE && p_header_data->p_next != NULL )
 149         {
 150             p_header_data = p_header_data->p_next;
 151         }
 152         else
 153         {
 154             break;
 155         }
 156     }
 157
 158     if( i_done != PES_HEADER_SIZE )
 159     {
 160         intf_WarnMsg( 3, "PES packet too short to have a header" );
 161         p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 162         p_pes = NULL;
 163         return;
 164     }
 165
 166     /* Get the PES size if defined */
 167     p_es->i_pes_real_size = U16_AT(p_header + 4) + 6;
 168
 169     /* First read the 6 header bytes common to all PES packets:
 170      * use them to test the PES validity */
 171     if( (p_header[0] || p_header[1] || (p_header[2] != 1)) )
 172     {
 173         /* packet_start_code_prefix != 0x000001 */
 174         intf_ErrMsg( "PES packet doesn't start with 0x000001 : data loss" );
 175         p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 176         p_pes = NULL;
 177     }
 178     else
 179     {
 180         int i_pes_header_size, i_payload_size;
 181
 182         if ( p_es->i_pes_real_size &&
 183              (p_es->i_pes_real_size != p_pes->i_pes_size) )
 184         {
 185             /* PES_packet_length is set and != total received payload */
 186             /* Warn the decoder that the data may be corrupt. */
 187             intf_WarnMsg( 3, "PES sizes do not match : packet corrupted" );
 188             p_pes->b_messed_up = 1;
 189         }
 190
 191         switch( p_es->i_stream_id )
 192         {
 193         case 0xBC:  /* Program stream map */
 194         case 0xBE:  /* Padding */
 195         case 0xBF:  /* Private stream 2 */
 196         case 0xB0:  /* ECM */
 197         case 0xB1:  /* EMM */
 198         case 0xFF:  /* Program stream directory */
 199         case 0xF2:  /* DSMCC stream */
 200         case 0xF8:  /* ITU-T H.222.1 type E stream */
 201             /* The payload begins immediately after the 6 bytes header, so
 202              * we have finished with the parsing */
 203             i_pes_header_size = 6;
 204             break;
 205
 206         default:
 207             if( (p_header[6] & 0xC0) == 0x80 )
 208             {
 209                 /* MPEG-2 : the PES header contains at least 3 more bytes. */
 210                 p_pes->b_data_alignment = p_header[6] & 0x04;
 211                 p_pes->b_has_pts = p_header[7] & 0x80;
 212                 i_pes_header_size = p_header[8] + 9;
 213
 214                 /* Now parse the optional header extensions (in the limit of
 215                  * the 14 bytes). */
 216                 if( p_pes->b_has_pts )
 217                 {
 218                     p_pes->i_pts =
 219                       ( ((mtime_t)(p_header[9] & 0x0E) << 29) |
 220                         (((mtime_t)U16_AT(p_header + 10) << 14) - (1 << 14)) |
 221                         ((mtime_t)U16_AT(p_header + 12) >> 1) ) * 300;
 222                     p_pes->i_pts /= 27;
 223                 }
 224             }
 225             else
 226             {
 227                 /* Probably MPEG-1 */
 228                 byte_t *        p_byte;
 229                 data_packet_t * p_data;
 230
 231                 i_pes_header_size = 6;
 232                 p_data = p_pes->p_first;
 233                 p_byte = p_data->p_buffer + 6;
 234                 while( *p_byte == 0xFF && i_pes_header_size < 22 )
 235                 {
 236                     i_pes_header_size++;
 237                     p_byte++;
 238                     if( p_byte >= p_data->p_payload_end )
 239                     {
 240                         p_data = p_data->p_next;
 241                         if( p_data == NULL )
 242                         {
 243                             intf_ErrMsg( "MPEG-1 packet too short for header" );
 244                             p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 245                             p_pes = NULL;
 246                             return;
 247                         }
 248                         p_byte = p_data->p_payload_start;
 249                     }
 250                 }
 251                 if( i_pes_header_size == 22 )
 252                 {
 253                     intf_ErrMsg( "Too much MPEG-1 stuffing" );
 254                     p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 255                     p_pes = NULL;
 256                     return;
 257                 }
 258
 259                 if( (*p_byte & 0xC0) == 0x40 )
 260                 {
 261                     /* Don't ask why... --Meuuh */
 262                     p_byte += 2;
 263                     i_pes_header_size += 2;
 264                     if( p_byte >= p_data->p_payload_end )
 265                     {
 266                         int i_plus = p_byte - p_data->p_payload_end;
 267                         p_data = p_data->p_next;
 268                         if( p_data == NULL )
 269                         {
 270                             intf_ErrMsg( "MPEG-1 packet too short for header" );
 271                             p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 272                             p_pes = NULL;
 273                             return;
 274                         }
 275                         p_byte = p_data->p_payload_start + i_plus;
 276                     }
 277                 }
 278
 279                 i_pes_header_size++;
 280                 p_pes->b_has_pts = *p_byte & 0x20;
 281
 282                 if( *p_byte & 0x10 )
 283                 {
 284                     /* DTS */
 285                     i_pes_header_size += 5;
 286                 }
 287                 if( *p_byte & 0x20 )
 288                 {
 289                     /* PTS */
 290                     byte_t      p_pts[5];
 291                     int         i;
 292
 293                     i_pes_header_size += 4;
 294                     p_pts[0] = *p_byte;
 295                     for( i = 1; i < 5; i++ )
 296                     {
 297                         p_byte++;
 298                         if( p_byte >= p_data->p_payload_end )
 299                         {
 300                             p_data = p_data->p_next;
 301                             if( p_data == NULL )
 302                             {
 303                                 intf_ErrMsg( "MPEG-1 packet too short for header" );
 304                                 p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 305                                 p_pes = NULL;
 306                                 return;
 307                             }
 308                             p_byte = p_data->p_payload_start;
 309                         }
 310
 311                         p_pts[i] = *p_byte;
 312                     }
 313                     p_pes->i_pts =
 314                       ( ((mtime_t)(p_pts[0] & 0x0E) << 29) |
 315                         (((mtime_t)U16_AT(p_pts + 1) << 14) - (1 << 14)) |
 316                         ((mtime_t)U16_AT(p_pts + 3) >> 1) ) * 300;
 317                     p_pes->i_pts /= 27;
 318                 }
 319             }
 320
 321             /* PTS management */
 322             if( p_pes->b_has_pts )
 323             {
 324                 //intf_Msg("%lld\n", p_pes->i_pts);
 325                 switch( p_es->p_pgrm->i_synchro_state )
 326                 {
 327                 case SYNCHRO_NOT_STARTED:
 328                 case SYNCHRO_START:
 329                     p_pes->b_has_pts = 0;
 330                     break;
 331
 332                 case SYNCHRO_REINIT: /* We skip a PES | Why ?? --Meuuh */
 333                     p_pes->b_has_pts = 0;
 334                     p_es->p_pgrm->i_synchro_state = SYNCHRO_START;
 335                     break;
 336
 337                 case SYNCHRO_OK:
 338                     p_pes->i_pts += p_es->p_pgrm->delta_cr
 339                                          + p_es->p_pgrm->delta_absolute
 340                                          + DEFAULT_PTS_DELAY;
 341                     break;
 342                 }
 343             }
 344             break;
 345         }
 346
 347         /* Now we've parsed the header, we just have to indicate in some
 348          * specific data packets where the PES payload begins (renumber
 349          * p_payload_start), so that the decoders can find the beginning
 350          * of their data right out of the box. */
 351         p_header_data = p_pes->p_first;
 352         i_payload_size = p_header_data->p_payload_end
 353                                  - p_header_data->p_payload_start;
 354         while( i_pes_header_size > i_payload_size )
 355         {
 356             /* These packets are entirely filled by the PES header. */
 357             i_pes_header_size -= i_payload_size;
 358             p_header_data->p_payload_start = p_header_data->p_payload_end;
 359             /* Go to the next data packet. */
 360             if( (p_header_data = p_header_data->p_next) == NULL )
 361             {
 362                 intf_ErrMsg( "PES header bigger than payload" );
 363                 p_input->p_plugin->pf_delete_pes( p_input->p_method_data,
 364                                                   p_pes );
 365                 p_pes = NULL;
 366                 return;
 367             }
 368             i_payload_size = p_header_data->p_payload_end
 369                                  - p_header_data->p_payload_start;
 370         }
 371         /* This last packet is partly header, partly payload. */
 372         if( i_payload_size < i_pes_header_size )
 373         {
 374             intf_ErrMsg( "PES header bigger than payload" );
 375             p_input->p_plugin->pf_delete_pes( p_input->p_method_data, p_pes );
 376             p_pes = NULL;
 377             return;
 378         }
 379         p_header_data->p_payload_start += i_pes_header_size;
 380
 381         /* Now we can eventually put the PES packet in the decoder's
 382          * PES fifo */
 383         input_DecodePES( p_input, p_es );
 384     }
 385 #undef p_pes
 386 }
 387
 388 /*****************************************************************************
 389  * input_GatherPES:
 390  *****************************************************************************
 391  * Gather a PES packet.
 392  *****************************************************************************/
 393 void input_GatherPES( input_thread_t * p_input, data_packet_t *p_data,
 394                       es_descriptor_t * p_es,
 395                       boolean_t b_unit_start, boolean_t b_packet_lost )
 396 {
 397 #define p_pes (p_es->p_pes)
 398
 399     //intf_DbgMsg("PES-demultiplexing %p (%p)\n", p_ts_packet, p_pes);
 400
 401     /* If we lost data, insert an NULL data packet (philosophy : 0 is quite
 402      * often an escape sequence in decoders, so that should make them wait
 403      * for the next start code). */
 404     if( b_packet_lost && p_pes != NULL )
 405     {
 406         data_packet_t *             p_pad_data;
 407         if( (p_pad_data = p_input->p_plugin->pf_new_packet( p_input,
 408                                             PADDING_PACKET_SIZE )) == NULL )
 409         {
 410             intf_ErrMsg("Out of memory\n");
 411             p_input->b_error = 1;
 412             return;
 413         }
 414         memset( p_data->p_buffer, 0, PADDING_PACKET_SIZE );
 415         p_pad_data->b_discard_payload = 1;
 416         p_pes->b_messed_up = 1;
 417         input_GatherPES( p_input, p_pad_data, p_es, 0, 0 );
 418     }
 419
 420     if( b_unit_start && p_pes != NULL )
 421     {
 422         /* If the TS packet contains the begining of a new PES packet, and
 423          * if we were reassembling a PES packet, then the PES should be
 424          * complete now, so parse its header and give it to the decoders. */
 425         input_ParsePES( p_input, p_es );
 426     }
 427
 428     if( !b_unit_start && p_pes == NULL )
 429     {
 430         /* Random access... */
 431         p_input->p_plugin->pf_delete_packet( p_input->p_method_data, p_data );
 432     }
 433     else
 434     {
 435         if( b_unit_start )
 436         {
 437             /* If we are at the beginning of a new PES packet, we must fetch
 438              * a new PES buffer to begin with the reassembly of this PES
 439              * packet. This is also here that we can synchronize with the
 440              * stream if we lost packets or if the decoder has just
 441              * started. */
 442             if( (p_pes = p_input->p_plugin->pf_new_pes( p_input->p_method_data ) ) == NULL )
 443             {
 444                 intf_ErrMsg("Out of memory");
 445                 p_input->b_error = 1;
 446                 return;
 447             }
 448             //intf_DbgMsg("New PES packet %p (first data: %p)\n", p_pes, p_data);
 449             p_pes->p_first = p_data;
 450
 451             /* If the PES header fits in the first data packet, we can
 452              * already set p_gather->i_pes_real_size. */
 453             if( p_data->p_payload_end - p_data->p_payload_start
 454                     >= PES_HEADER_SIZE )
 455             {
 456                 p_es->i_pes_real_size =
 457                                 U16_AT(p_data->p_payload_start + 4) + 6;
 458             }
 459             else
 460             {
 461                 p_es->i_pes_real_size = 0;
 462             }
 463         }
 464         else
 465         {
 466             /* Update the relations between the data packets */
 467             p_es->p_last->p_next = p_data;
 468         }
 469
 470         p_data->p_next = NULL;
 471         p_es->p_last = p_data;
 472
 473         /* Size of the payload carried in the data packet */
 474         p_pes->i_pes_size += (p_data->p_payload_end
 475                                  - p_data->p_payload_start);
 476
 477         /* We can check if the packet is finished */
 478         if( p_pes->i_pes_size == p_es->i_pes_real_size )
 479         {
 480             /* The packet is finished, parse it */
 481             input_ParsePES( p_input, p_es );
 482         }
 483     }
 484 #undef p_pes
 485 }
 486
 487
 488 /*
 489  * Pace control
 490  */
 491
 492 /*
 493  *   DISCUSSION : SYNCHRONIZATION METHOD
 494  *
 495  *   In some cases we can impose the pace of reading (when reading from a
 496  *   file or a pipe), and for the synchronization we simply sleep() until
 497  *   it is time to deliver the packet to the decoders. When reading from
 498  *   the network, we must be read at the same pace as the server writes,
 499  *   otherwise the kernel's buffer will trash packets. The risk is now to
 500  *   overflow the input buffers in case the server goes too fast, that is
 501  *   why we do these calculations :
 502  *
 503  *   We compute an average for the pcr because we want to eliminate the
 504  *   network jitter and keep the low frequency variations. The average is
 505  *   in fact a low pass filter and the jitter is a high frequency signal
 506  *   that is why it is eliminated by the filter/average.
 507  *
 508  *   The low frequency variations enable us to synchronize the client clock
 509  *   with the server clock because they represent the time variation between
 510  *   the 2 clocks. Those variations (ie the filtered pcr) are used to compute
 511  *   the presentation dates for the audio and video frames. With those dates
 512  *   we can decode (or trash) the MPEG2 stream at "exactly" the same rate
 513  *   as it is sent by the server and so we keep the synchronization between
 514  *   the server and the client.
 515  *
 516  *   It is a very important matter if you want to avoid underflow or overflow
 517  *   in all the FIFOs, but it may be not enough.
 518  */
 519
 520 /*****************************************************************************
 521  * Constants
 522  *****************************************************************************/
 523
 524 /* Maximum number of samples used to compute the dynamic average value,
 525  * it is also the maximum of c_average_count in pgrm_ts_data_t.
 526  * We use the following formula :
 527  * new_average = (old_average * c_average + new_sample_value) / (c_average +1) */
 528 #define CR_MAX_AVERAGE_COUNTER 40
 529
 530 /* Maximum gap allowed between two CRs. */
 531 #define CR_MAX_GAP 1000000
 532
 533 /*****************************************************************************
 534  * CRReInit : Reinitialize the clock reference
 535  *****************************************************************************/
 536 static void CRReInit( pgrm_descriptor_t * p_pgrm )
 537 {
 538     p_pgrm->delta_cr        = 0;
 539     p_pgrm->last_cr         = 0;
 540     p_pgrm->c_average_count = 0;
 541 }
 542
 543 /* FIXME: find a better name */
 544 /*****************************************************************************
 545  * CRDecode : Decode a clock reference
 546  *****************************************************************************/
 547 static void CRDecode( input_thread_t * p_input, pgrm_descriptor_t * p_pgrm,
 548                       mtime_t cr_time )
 549 {
 550     if( p_pgrm->i_synchro_state != SYNCHRO_OK )
 551     {
 552         switch( p_pgrm->i_synchro_state )
 553         {
 554         case SYNCHRO_START:
 555             p_pgrm->delta_absolute = mdate() - cr_time;
 556             p_pgrm->i_synchro_state = SYNCHRO_OK;
 557             break;
 558
 559         case SYNCHRO_NOT_STARTED:
 560             p_pgrm->i_synchro_state = SYNCHRO_START;
 561             break;
 562
 563         default:
 564             break;
 565         }
 566     }
 567     else
 568     {
 569         if( p_pgrm->b_discontinuity ||
 570             ( p_pgrm->last_cr != 0 &&
 571                   (    (p_pgrm->last_cr - cr_time) > CR_MAX_GAP
 572                     || (p_pgrm->last_cr - cr_time) < - CR_MAX_GAP ) ) )
 573         {
 574             /* Stream discontinuity. */
 575             intf_WarnMsg( 3, "CR re-initialiazed" );
 576             CRReInit( p_pgrm );
 577             p_pgrm->i_synchro_state = SYNCHRO_REINIT;
 578             p_pgrm->b_discontinuity = 0;
 579         }
 580         p_pgrm->last_cr = cr_time;
 581
 582         if( p_input->stream.b_pace_control )
 583         {
 584             /* Wait a while before delivering the packets to the decoder. */
 585             mwait( cr_time + p_pgrm->delta_absolute );
 586         }
 587         else
 588         {
 589             mtime_t                 sys_time, delta_cr;
 590
 591             sys_time = mdate();
 592             delta_cr = sys_time - cr_time;
 593
 594             if( p_pgrm->c_average_count == CR_MAX_AVERAGE_COUNTER )
 595             {
 596                 p_pgrm->delta_cr = ( delta_cr + (p_pgrm->delta_cr
 597                                               * (CR_MAX_AVERAGE_COUNTER - 1)) )
 598                                      / CR_MAX_AVERAGE_COUNTER;
 599             }
 600             else
 601             {
 602                 p_pgrm->delta_cr = ( delta_cr + (p_pgrm->delta_cr
 603                                               * p_pgrm->c_average_count) )
 604                                      / ( p_pgrm->c_average_count + 1 );
 605                 p_pgrm->c_average_count++;
 606             }
 607         }
 608     }
 609 }
 610
 611
 612 /*
 613  * PS Demultiplexing
 614  */
 615
 616 /*****************************************************************************
 617  * DecodePSM: Decode the Program Stream Map information
 618  *****************************************************************************/
 619 static void DecodePSM( input_thread_t * p_input, data_packet_t * p_data )
 620 {
 621     stream_ps_data_t *  p_demux =
 622                  (stream_ps_data_t *)p_input->stream.p_demux_data;
 623
 624     if( !p_demux->b_is_PSM_complete )
 625     {
 626         byte_t *    p_byte;
 627         byte_t *    p_end;
 628         int         i_es = 0;
 629
 630         intf_DbgMsg( "Building PSM" );
 631         if( p_data->p_payload_start + 10 > p_data->p_payload_end )
 632         {
 633             intf_ErrMsg( "PSM too short : packet corrupt" );
 634             return;
 635         }
 636         /* Go to elementary_stream_map_length, jumping over
 637          * program_stream_info. */
 638         p_byte = p_data->p_payload_start + 10
 639                   + U16_AT(&p_data->p_payload_start[8]);
 640         if( p_byte > p_data->p_payload_end )
 641         {
 642             intf_ErrMsg( "PSM too short : packet corrupt" );
 643             return;
 644         }
 645         /* This is the full size of the elementary_stream_map.
 646          * 2 == elementary_stream_map_length
 647          * 4 == CRC_32 */
 648         p_end = p_byte + 2 + U16_AT(p_byte) - 4;
 649         p_byte += 2;
 650         if( p_end > p_data->p_payload_end )
 651         {
 652             intf_ErrMsg( "PSM too short : packet corrupt" );
 653             return;
 654         }
 655
 656         vlc_mutex_lock( &p_input->stream.stream_lock );
 657
 658         /* 4 == minimum useful size of a section */
 659         while( p_byte + 4 <= p_end )
 660         {
 661             p_input->p_es[i_es].i_id
 662                 = p_input->p_es[i_es].i_stream_id
 663                 = p_byte[1];
 664             p_input->p_es[i_es].i_type = p_byte[0];
 665             p_input->p_es[i_es].p_pgrm = p_input->stream.pp_programs[0];
 666             p_input->p_es[i_es].p_pes = NULL;
 667             p_byte += 4 + U16_AT(&p_byte[2]);
 668
 669 #ifdef AUTO_SPAWN
 670             switch( p_input->p_es[i_es].i_type )
 671             {
 672                 case MPEG1_AUDIO_ES:
 673                 case MPEG2_AUDIO_ES:
 674                     /* Spawn audio thread. */
 675                     intf_DbgMsg( "Starting an MPEG-audio decoder" );
 676                     break;
 677
 678                 case MPEG1_VIDEO_ES:
 679                 case MPEG2_VIDEO_ES:
 680                     /* Spawn video thread. */
 681                     intf_DbgMsg( "Starting an MPEG-video decoder" );
 682                     break;
 683             }
 684 #endif
 685
 686             i_es++;
 687         }
 688
 689         vlc_mutex_unlock( &p_input->stream.stream_lock );
 690         p_demux->i_PSM_version = p_data->p_buffer[6] & 0x1F;
 691         p_demux->b_is_PSM_complete = 1;
 692     }
 693     else if( p_demux->i_PSM_version != (p_data->p_buffer[6] & 0x1F) )
 694     {
 695         /* FIXME */
 696         intf_ErrMsg( "PSM changed, this is not supported yet !" );
 697         p_demux->i_PSM_version = p_data->p_buffer[6] & 0x1F;
 698     }
 699 }
 700
 701 /*****************************************************************************
 702  * input_DemuxPS: first step of demultiplexing: the PS header
 703  *****************************************************************************/
 704 void input_DemuxPS( input_thread_t * p_input, data_packet_t * p_data )
 705 {
 706     u32                 i_code;
 707     boolean_t           b_trash = 0;
 708     es_descriptor_t *   p_es = NULL;
 709
 710     i_code = U32_AT( p_data->p_buffer );
 711     if( i_code >= 0x1B9 && i_code <= 0x1BC )
 712     {
 713         switch( i_code )
 714         {
 715         case 0x1BA: /* PACK_START_CODE */
 716             {
 717                 /* Convert the SCR in microseconds. */
 718                 mtime_t         scr_time;
 719
 720                 if( (p_data->p_buffer[4] & 0xC0) == 0x40 )
 721                 {
 722                     /* MPEG-2 */
 723                     scr_time =
 724                       (( ((mtime_t)(p_data->p_buffer[4] & 0x38) << 27) |
 725                          ((mtime_t)(U32_AT(p_data->p_buffer + 4) & 0x03FFF800)
 726                                         << 4) |
 727                          ((mtime_t)(U32_AT(p_data->p_buffer + 6) & 0x03FFF800)
 728                                         >> 11)
 729                       ) * 300) / 27;
 730                 }
 731                 else
 732                 {
 733                     /* MPEG-1 SCR is like PTS */
 734                     scr_time =
 735                       (( ((mtime_t)(p_data->p_buffer[4] & 0x0E) << 29) |
 736                          (((mtime_t)U16_AT(p_data->p_buffer + 5) << 14)
 737                            - (1 << 14)) |
 738                          ((mtime_t)U16_AT(p_data->p_buffer + 7) >> 1)
 739                       ) * 300) / 27;
 740                 }
 741                 /* Call the pace control. */
 742                 //intf_Msg("+%lld\n", scr_time);
 743                 CRDecode( p_input, p_input->stream.pp_programs[0],
 744                           scr_time );
 745                 b_trash = 1;
 746             }
 747             break;
 748
 749         case 0x1BB: /* SYSTEM_START_CODE */
 750             b_trash = 1;                              /* Nothing interesting */
 751             break;
 752
 753         case 0x1BC: /* PROGRAM_STREAM_MAP_CODE */
 754             intf_ErrMsg("meuuuuh\n");
 755             DecodePSM( p_input, p_data );
 756             b_trash = 1;
 757             break;
 758
 759         case 0x1B9: /* PROGRAM_END_CODE */
 760             b_trash = 1;
 761             break;
 762
 763         default:
 764             /* This should not happen */
 765             b_trash = 1;
 766             intf_WarnMsg( 1, "Unwanted packet received with start code %x",
 767                           i_code );
 768         }
 769     }
 770     else
 771     {
 772         u16                 i_id;
 773         int                 i_dummy;
 774
 775         /* This is a PES packet. Find out if we want it or not. */
 776         i_id = p_data->p_buffer[3];                     /* ID of the stream. */
 777
 778         vlc_mutex_lock( &p_input->stream.stream_lock );
 779         for( i_dummy = 0; i_dummy < INPUT_MAX_ES; i_dummy++ )
 780         {
 781             if( p_input->p_es[i_dummy].i_id == i_id )
 782             {
 783                 p_es = &p_input->p_es[i_dummy];
 784                 break;
 785             }
 786         }
 787         vlc_mutex_unlock( &p_input->stream.stream_lock );
 788
 789         if( p_es == NULL )
 790         {
 791 #if 1
 792             /* FIXME ! */
 793             if( (i_id & 0xC0L) == 0xC0L )
 794             {
 795                 /* MPEG video and audio */
 796                 for( i_dummy = 0; i_dummy < INPUT_MAX_ES; i_dummy++ )
 797                 {
 798                     if( p_input->p_es[i_dummy].i_id == EMPTY_ID )
 799                     {
 800                         p_es = &p_input->p_es[i_dummy];
 801                         break;
 802                     }
 803                 }
 804
 805                 if( p_es != NULL && (i_id & 0xF0L) == 0xE0L )
 806                 {
 807                     /* MPEG video */
 808                     vdec_config_t * p_config;
 809                     p_es->i_id = p_es->i_stream_id = i_id;
 810                     p_es->i_type = MPEG2_VIDEO_ES;
 811                     p_es->p_pgrm = p_input->stream.pp_programs[0];
 812                     p_es->p_pes = NULL;
 813
 814 #ifdef AUTO_SPAWN
 815                     p_config = (vdec_config_t *)malloc( sizeof(vdec_config_t) );
 816                     p_config->p_vout = p_input->p_default_vout;
 817                     /* FIXME ! */
 818                     p_config->decoder_config.i_stream_id = i_id;
 819                     p_config->decoder_config.i_type = MPEG2_VIDEO_ES;
 820                     p_config->decoder_config.p_stream_ctrl =
 821                         &p_input->stream.control;
 822                     p_config->decoder_config.p_decoder_fifo =
 823                         (decoder_fifo_t *)malloc( sizeof(decoder_fifo_t) );
 824                     vlc_mutex_init(&p_config->decoder_config.p_decoder_fifo->data_lock);
 825                     vlc_cond_init(&p_config->decoder_config.p_decoder_fifo->data_wait);
 826                     p_config->decoder_config.p_decoder_fifo->i_start =
 827                         p_config->decoder_config.p_decoder_fifo->i_end = 0;
 828                     p_config->decoder_config.p_decoder_fifo->b_die = 0;
 829                     p_config->decoder_config.p_decoder_fifo->p_packets_mgt =
 830                         p_input->p_method_data;
 831                     p_config->decoder_config.p_decoder_fifo->pf_delete_pes =
 832                         p_input->p_plugin->pf_delete_pes;
 833                     p_es->p_decoder_fifo = p_config->decoder_config.p_decoder_fifo;
 834                     p_config->decoder_config.pf_init_bit_stream =
 835                         InitBitstream;
 836                     for( i_dummy = 0; i_dummy < INPUT_MAX_SELECTED_ES; i_dummy++ )
 837                     {
 838                         if( p_input->pp_selected_es[i_dummy] == NULL )
 839                         {
 840                             p_input->pp_selected_es[i_dummy] = p_es;
 841                             break;
 842                         }
 843                     }
 844
 845                     p_es->thread_id = vpar_CreateThread( p_config );
 846 #endif
 847                 }
 848                 else if( p_es != NULL && (i_id & 0xE0) == 0xC0 )
 849                 {
 850                     /* MPEG audio */
 851                     adec_config_t * p_config;
 852                     p_es->i_id = p_es->i_stream_id = i_id;
 853                     p_es->i_type = MPEG2_AUDIO_ES;
 854                     p_es->p_pgrm = p_input->stream.pp_programs[0];
 855                     p_es->p_pes = NULL;
 856
 857 #ifdef AUTO_SPAWN
 858                     p_config = (adec_config_t *)malloc( sizeof(adec_config_t) );
 859                     p_config->p_aout = p_input->p_default_aout;
 860                     /* FIXME ! */
 861                     p_config->decoder_config.i_stream_id = i_id;
 862                     p_config->decoder_config.i_type = MPEG2_AUDIO_ES;
 863                     p_config->decoder_config.p_stream_ctrl =
 864                         &p_input->stream.control;
 865                     p_config->decoder_config.p_decoder_fifo =
 866                         (decoder_fifo_t *)malloc( sizeof(decoder_fifo_t) );
 867                     vlc_mutex_init(&p_config->decoder_config.p_decoder_fifo->data_lock);
 868                     vlc_cond_init(&p_config->decoder_config.p_decoder_fifo->data_wait);
 869                     p_config->decoder_config.p_decoder_fifo->i_start =
 870                         p_config->decoder_config.p_decoder_fifo->i_end = 0;
 871                     p_config->decoder_config.p_decoder_fifo->b_die = 0;
 872                     p_config->decoder_config.p_decoder_fifo->p_packets_mgt =
 873                         p_input->p_method_data;
 874                     p_config->decoder_config.p_decoder_fifo->pf_delete_pes =
 875                         p_input->p_plugin->pf_delete_pes;
 876                     p_es->p_decoder_fifo = p_config->decoder_config.p_decoder_fifo;
 877                     p_config->decoder_config.pf_init_bit_stream =
 878                         InitBitstream;
 879                     for( i_dummy = 0; i_dummy < INPUT_MAX_SELECTED_ES; i_dummy++ )
 880                     {
 881                         if( p_input->pp_selected_es[i_dummy] == NULL )
 882                         {
 883                             p_input->pp_selected_es[i_dummy] = p_es;
 884                             break;
 885                         }
 886                     }
 887
 888                     p_es->thread_id = adec_CreateThread( p_config );
 889 #endif
 890                 }
 891                 else
 892                 {
 893                     b_trash = 1;
 894                 }
 895             }
 896             else
 897                 b_trash = 1;
 898 #else
 899             b_trash = 1;
 900 #endif
 901         }
 902
 903         if( p_es != NULL )
 904         {
 905 #ifdef STATS
 906             p_es->c_packets++;
 907 #endif
 908             input_GatherPES( p_input, p_data, p_es, 1, 0 );
 909         }
 910     }
 911
 912     /* Trash the packet if it has no payload or if it isn't selected */
 913     if( b_trash )
 914     {
 915         p_input->p_plugin->pf_delete_packet( p_input, p_data );
 916 #ifdef STATS
 917         p_input->c_packets_trashed++;
 918 #endif
 919     }
 920 }
 921
 922
 923 /*
 924  * TS Demultiplexing
 925  */
 926
 927 /*****************************************************************************
 928  * input_DemuxTS: first step of demultiplexing: the TS header
 929  *****************************************************************************/
 930 void input_DemuxTS( input_thread_t * p_input, data_packet_t * p_data )
 931 {
 932     int                 i_pid, i_dummy;
 933     boolean_t           b_adaptation;         /* Adaptation field is present */
 934     boolean_t           b_payload;                 /* Packet carries payload */
 935     boolean_t           b_unit_start;  /* A PSI or a PES start in the packet */
 936     boolean_t           b_trash = 0;             /* Is the packet unuseful ? */
 937     boolean_t           b_lost = 0;             /* Was there a packet loss ? */
 938     es_descriptor_t *   p_es = NULL;
 939     es_ts_data_t *      p_es_demux = NULL;
 940     pgrm_ts_data_t *    p_pgrm_demux = NULL;
 941
 942 #define p (p_data->p_buffer)
 943
 944     //intf_DbgMsg("input debug: TS-demultiplexing packet %p, pid %d\n",
 945     //            p_ts_packet, U16_AT(&p[1]) & 0x1fff);
 946
 947     /* Extract flags values from TS common header. */
 948     i_pid = U16_AT(&p[1]) & 0x1fff;
 949     b_unit_start = (p[1] & 0x40);
 950     b_adaptation = (p[3] & 0x20);
 951     b_payload = (p[3] & 0x10);
 952
 953     /* Find out the elementary stream. */
 954     vlc_mutex_lock( &p_input->stream.stream_lock );
 955     for( i_dummy = 0; i_dummy < INPUT_MAX_ES; i_dummy++ )
 956     {
 957         if( p_input->p_es[i_dummy].i_id != EMPTY_ID )
 958         {
 959             if( p_input->p_es[i_dummy].i_id == i_pid )
 960             {
 961                 p_es = &p_input->p_es[i_dummy];
 962                 p_es_demux = (es_ts_data_t *)p_es->p_demux_data;
 963                 p_pgrm_demux = (pgrm_ts_data_t *)p_es->p_pgrm->p_demux_data;
 964                 break;
 965             }
 966         }
 967     }
 968     vlc_mutex_unlock( &p_input->stream.stream_lock );
 969
 970 #ifdef STATS
 971     p_es->c_packets++;
 972 #endif
 973
 974     if( p_es->p_decoder_fifo == NULL )
 975     {
 976         /* Not selected. Just read the adaptation field for a PCR. */
 977         b_trash = 1;
 978     }
 979
 980     if( (p_es->p_decoder_fifo != NULL) || (p_pgrm_demux->i_pcr_pid == i_pid) )
 981     {
 982         /* Extract adaptation field information if any */
 983         if( !b_adaptation )
 984         {
 985             /* We don't have any adaptation_field, so payload starts
 986              * immediately after the 4 byte TS header */
 987             p_data->p_payload_start += 4;
 988         }
 989         else
 990         {
 991             /* p[4] is adaptation_field_length minus one */
 992             p_data->p_payload_start += 5 + p[4];
 993
 994             /* The adaptation field can be limited to the
 995              * adaptation_field_length byte, so that there is nothing to do:
 996              * skip this possibility */
 997             if( p[4] )
 998             {
 999                 /* If the packet has both adaptation_field and payload,
1000                  * adaptation_field cannot be more than 182 bytes long; if
1001                  * there is only an adaptation_field, it must fill the next
1002                  * 183 bytes. */
1003                 if( b_payload ? (p[4] > 182) : (p[4] != 183) )
1004                 {
1005                     intf_WarnMsg( 2,
1006                         "invalid TS adaptation field (%p)",
1007                         p_data );
1008                     p_data->b_discard_payload = 1;
1009 #ifdef STATS
1010                     p_es->c_invalid_packets++;
1011 #endif
1012                 }
1013
1014                 /* Now we are sure that the byte containing flags is present:
1015                  * read it */
1016                 else
1017                 {
1018                     /* discontinuity_indicator */
1019                     if( p[5] & 0x80 )
1020                     {
1021                         intf_WarnMsg( 2,
1022                             "discontinuity_indicator"                       \
1023                             " encountered by TS demux (position read: %d,"  \
1024                             " saved: %d)",
1025                             p[5] & 0x80, p_es_demux->i_continuity_counter );
1026
1027                         /* If the PID carries the PCR, there will be a system
1028                          * time-based discontinuity. We let the PCR decoder
1029                          * handle that. */
1030                         p_es->p_pgrm->b_discontinuity = 1;
1031
1032                         /* There also may be a continuity_counter
1033                          * discontinuity: resynchronise our counter with
1034                          * the one of the stream. */
1035                         p_es_demux->i_continuity_counter = (p[3] & 0x0f) - 1;
1036                     }
1037
1038                     /* If this is a PCR_PID, and this TS packet contains a
1039                      * PCR, we pass it along to the PCR decoder. */
1040                     if( (p_pgrm_demux->i_pcr_pid == i_pid) && (p[5] & 0x10) )
1041                     {
1042                         /* There should be a PCR field in the packet, check
1043                          * if the adaptation field is long enough to carry
1044                          * it. */
1045                         if( p[4] >= 7 )
1046                         {
1047                             /* Convert the PCR in microseconds.
1048                              * WARNING: do not remove the casts in the
1049                              * following calculation ! */
1050                             mtime_t     pcr_time;
1051                             pcr_time =
1052                                     ( (( (mtime_t)U32_AT((u32*)&p[6]) << 1 )
1053                                       | ( p[10] >> 7 )) * 300 ) / 27;
1054                             /* Call the pace control. */
1055                             CRDecode( p_input, p_es->p_pgrm, pcr_time );
1056                         }
1057                     } /* PCR ? */
1058                 } /* valid TS adaptation field ? */
1059             } /* length > 0 */
1060         } /* has adaptation field */
1061
1062         /* Check the continuity of the stream. */
1063         i_dummy = ((p[3] & 0x0f) - p_es_demux->i_continuity_counter) & 0x0f;
1064         if( i_dummy == 1 )
1065         {
1066             /* Everything is ok, just increase our counter */
1067             p_es_demux->i_continuity_counter++;
1068         }
1069         else
1070         {
1071             if( !b_payload && i_dummy == 0 )
1072             {
1073                 /* This is a packet without payload, this is allowed by the draft.
1074                  * As there is nothing interesting in this packet (except PCR that
1075                  * have already been handled), we can trash the packet. */
1076                 intf_WarnMsg( 1,
1077                               "Packet without payload received by TS demux" );
1078                 b_trash = 1;
1079             }
1080             else if( i_dummy <= 0 )
1081             {
1082                 /* FIXME: this can never happen, can it ? --Meuuh */
1083                 /* Duplicate packet: mark it as being to be trashed. */
1084                 intf_WarnMsg( 1, "Duplicate packet received by TS demux" );
1085                 b_trash = 1;
1086             }
1087             else if( p_es_demux->i_continuity_counter == 0xFF )
1088             {
1089                 /* This means that the packet is the first one we receive for this
1090                  * ES since the continuity counter ranges between 0 and 0x0F
1091                  * excepts when it has been initialized by the input: Init the
1092                  * counter to the correct value. */
1093                 intf_DbgMsg( "First packet for PID %d received by TS demux",
1094                              p_es->i_id );
1095                 p_es_demux->i_continuity_counter = (p[3] & 0x0f);
1096             }
1097             else
1098             {
1099                 /* This can indicate that we missed a packet or that the
1100                  * continuity_counter wrapped and we received a dup packet: as we
1101                  * don't know, do as if we missed a packet to be sure to recover
1102                  * from this situation */
1103                 intf_WarnMsg( 2,
1104                            "Packet lost by TS demux: current %d, packet %d\n",
1105                            p_es_demux->i_continuity_counter & 0x0f,
1106                            p[3] & 0x0f );
1107                 b_lost = 1;
1108                 p_es_demux->i_continuity_counter = p[3] & 0x0f;
1109             } /* not continuous */
1110         } /* continuity */
1111     } /* if selected or PCR */
1112
1113     /* Trash the packet if it has no payload or if it isn't selected */
1114     if( b_trash )
1115     {
1116         p_input->p_plugin->pf_delete_packet( p_input, p_data );
1117 #ifdef STATS
1118         p_input->c_packets_trashed++;
1119 #endif
1120     }
1121     else
1122     {
1123         if( p_es_demux->b_psi )
1124         {
1125             /* The payload contains PSI tables */
1126 #if 0
1127             input_DemuxPSI( p_input, p_data, p_es,
1128                             b_unit_start, b_lost );
1129 #endif
1130         }
1131         else
1132         {
1133             /* The payload carries a PES stream */
1134             if( b_unit_start )
1135             input_GatherPES( p_input, p_data, p_es, b_unit_start, b_lost );
1136         }
1137     }
1138
1139 #undef p
1140 }