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