libhb/demuxmpeg.c

   1 /* $Id: demuxmpeg.c,v 1.4 2004/10/19 23:11:36 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8
   9 static inline void check_mpeg_scr( hb_psdemux_t *state, int64_t scr, int tol )
  10 {
  11     /*
  12      * This section of code implements the timing model of
  13      * the "Standard Target Decoder" (STD) of the MPEG2 standard
  14      * (specified in ISO 13818-1 sections 2.4.2, 2.5.2 & Annex D).
  15      * The STD removes and corrects for clock discontinuities so
  16      * that the time stamps on the video, audio & other media
  17      * streams can be used for cross-media synchronization. To do
  18      * this the STD has its own timestamp value, the System Clock
  19      * Reference or SCR, in the PACK header. Clock discontinuities
  20      * are detected using the SCR & and the adjustment needed
  21      * to correct post-discontinuity timestamps to be contiguous
  22      * with pre-discontinuity timestamps is computed from pre- and
  23      * post-discontinuity values of the SCR. Then this adjustment
  24      * is applied to every media timestamp (PTS).
  25      *
  26      * ISO 13818-1 says there must be an SCR at least every 700ms
  27      * (100ms for Transport Streams) so if the difference between
  28      * this SCR & the previous is >700ms it's a discontinuity.
  29      * If the difference is negative it's non-physical (time doesn't
  30      * go backward) and must also be a discontinuity. When we find a
  31      * discontinuity we adjust the scr_offset so that the SCR of the
  32      * new packet lines up with that of the previous packet.
  33      */
  34
  35     // we declare a discontinuity if there's a gap of more than
  36     // 'tol'ms between the last scr & this or if this scr goes back
  37     // by more than half a frame time.
  38     int64_t scr_delta = scr - state->last_scr;
  39     if ( scr_delta > 90*tol || scr_delta < -90*10 )
  40     {
  41         ++state->scr_changes;
  42         state->last_pts = -1;
  43     }
  44     state->last_scr = scr;
  45 }
  46
  47 /* Basic MPEG demuxer */
  48
  49 int hb_demux_ps( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
  50 {
  51     hb_buffer_t * buf_es;
  52     int           pos = 0;
  53
  54 #define d (buf_ps->data)
  55
  56     /* pack_header */
  57     if( d[pos] != 0 || d[pos+1] != 0 ||
  58         d[pos+2] != 0x1 || d[pos+3] != 0xBA )
  59     {
  60         hb_log( "hb_demux_ps: not a PS packet (%02x%02x%02x%02x)",
  61                 d[pos], d[pos+1], d[pos+2], d[pos+3] );
  62         return 0;
  63     }
  64     pos += 4;                    /* pack_start_code */
  65
  66     if ( state )
  67     {
  68         /* extract the system clock reference (scr) */
  69         int64_t scr = ((uint64_t)(d[pos] & 0x38) << 27) |
  70                       ((uint64_t)(d[pos] & 0x03) << 28) |
  71                       ((uint64_t)(d[pos+1]) << 20) |
  72                       ((uint64_t)(d[pos+2] >> 3) << 15) |
  73                       ((uint64_t)(d[pos+2] & 3) << 13) |
  74                       ((uint64_t)(d[pos+3]) << 5) |
  75                       (d[pos+4] >> 3);
  76         check_mpeg_scr( state, scr, 300 );
  77     }
  78
  79     pos += 9;                    /* pack_header */
  80     pos += 1 + ( d[pos] & 0x7 ); /* stuffing bytes */
  81
  82     /* system_header */
  83     if( d[pos] == 0 && d[pos+1] == 0 &&
  84         d[pos+2] == 0x1 && d[pos+3] == 0xBB )
  85     {
  86         int header_length;
  87
  88         pos           += 4; /* system_header_start_code */
  89         header_length  = ( d[pos] << 8 ) + d[pos+1];
  90         pos           += 2 + header_length;
  91     }
  92
  93     /* pes */
  94     while( pos + 6 < buf_ps->size &&
  95            d[pos] == 0 && d[pos+1] == 0 && d[pos+2] == 0x1 )
  96     {
  97         int      id;
  98         int      pes_packet_length;
  99         int      pes_packet_end;
 100         int      pes_header_d_length;
 101         int      pes_header_end;
 102         int      has_pts;
 103         int64_t  pts = -1, dts = -1;
 104
 105         pos               += 3;               /* packet_start_code_prefix */
 106         id           = d[pos];
 107         pos               += 1;
 108
 109         pes_packet_length  = ( d[pos] << 8 ) + d[pos+1];
 110         pos               += 2;               /* pes_packet_length */
 111         pes_packet_end     = pos + pes_packet_length;
 112
 113         if( id != 0xE0 && id != 0xBD &&
 114             ( id & 0xC0 ) != 0xC0  )
 115         {
 116             /* Not interesting */
 117             pos = pes_packet_end;
 118             continue;
 119         }
 120
 121         has_pts            = d[pos+1] >> 6;
 122         pos               += 2;               /* Required headers */
 123
 124         pes_header_d_length  = d[pos];
 125         pos                    += 1;
 126         pes_header_end          = pos + pes_header_d_length;
 127
 128         if( has_pts )
 129         {
 130             pts = ( (uint64_t)(d[pos] & 0xe ) << 29 ) +
 131                   ( d[pos+1] << 22 ) +
 132                   ( ( d[pos+2] >> 1 ) << 15 ) +
 133                   ( d[pos+3] << 7 ) +
 134                   ( d[pos+4] >> 1 );
 135             if ( has_pts & 1 )
 136             {
 137                 dts = ( (uint64_t)(d[pos+5] & 0xe ) << 29 ) +
 138                       ( d[pos+6] << 22 ) +
 139                       ( ( d[pos+7] >> 1 ) << 15 ) +
 140                       ( d[pos+8] << 7 ) +
 141                       ( d[pos+9] >> 1 );
 142             }
 143             else
 144             {
 145                 dts = pts;
 146             }
 147         }
 148
 149         pos = pes_header_end;
 150
 151         if( id == 0xBD )
 152         {
 153             id |= ( d[pos] << 8 );
 154             if( ( id & 0xF0FF ) == 0x80BD ) /* A52 */
 155             {
 156                 pos += 4;
 157             }
 158             else if( ( id & 0xE0FF ) == 0x20BD || /* SPU */
 159                      ( id & 0xF0FF ) == 0xA0BD )  /* LPCM */
 160             {
 161                 pos += 1;
 162             }
 163         }
 164
 165         /* Sanity check */
 166         if( pos >= pes_packet_end )
 167         {
 168             pos = pes_packet_end;
 169             continue;
 170         }
 171
 172         /* Here we hit we ES payload */
 173         buf_es = hb_buffer_init( pes_packet_end - pos );
 174
 175         buf_es->id       = id;
 176         buf_es->start    = pts;
 177         buf_es->renderOffset = dts;
 178         buf_es->stop     = -1;
 179         if (id == 0xE0) {
 180             // Consume a chapter break, and apply it to the ES.
 181             buf_es->new_chap = buf_ps->new_chap;
 182             buf_ps->new_chap = 0;
 183         }
 184         memcpy( buf_es->data, d + pos, pes_packet_end - pos );
 185
 186         hb_list_add( list_es, buf_es );
 187
 188         pos = pes_packet_end;
 189     }
 190
 191 #undef d
 192
 193     return 1;
 194 }
 195
 196 // mpeg transport stream demuxer. the elementary stream headers have been
 197 // stripped off and buf_ps has all the info gleaned from them: id is set,
 198 // start contains the pts (if any), renderOffset contains the dts (if any)
 199 // and stop contains the pcr (if it changed).
 200 int hb_demux_ts( hb_buffer_t *buf_ps, hb_list_t *list_es, hb_psdemux_t *state )
 201 {
 202     if ( state )
 203     {
 204         // we're keeping track of timing (i.e., not in scan)
 205         // check if there's a new pcr in this packet
 206         if ( buf_ps->stop >= 0 )
 207         {
 208             // we have a new pcr
 209             check_mpeg_scr( state, buf_ps->stop, 300 );
 210             buf_ps->stop = -1;
 211         }
 212         if ( buf_ps->start >= 0 )
 213         {
 214             // Program streams have an SCR in every PACK header so they
 215             // can't lose their clock reference. But the PCR in Transport
 216             // streams is typically on <.1% of the packets. If a PCR
 217             // packet gets lost and it marks a clock discontinuity then
 218             // the data following it will be referenced to the wrong
 219             // clock & introduce huge gaps or throw our A/V sync off.
 220             // We try to protect against that here by sanity checking
 221             // timestamps against the current reference clock and discarding
 222             // packets where the DTS is "too far" from its clock.
 223             int64_t fdelta = buf_ps->start - state->last_scr;
 224             if ( fdelta < -300 * 90000LL || fdelta > 300 * 90000LL )
 225             {
 226                 // packet too far behind or ahead of its clock reference
 227                 ++state->dts_drops;
 228                 return 1;
 229             }
 230             if ( state->last_pts >= 0 )
 231             {
 232                 fdelta = buf_ps->start - state->last_pts;
 233                 if ( fdelta < -5 * 90000LL || fdelta > 5 * 90000LL )
 234                 {
 235                     // Packet too far from last. This may be a NZ TV broadcast
 236                     // as they like to change the PCR without sending a PCR
 237                     // update. Since it may be a while until they actually tell
 238                     // us the new PCR use the PTS as the PCR.
 239                     ++state->scr_changes;
 240                     state->last_scr = buf_ps->start;
 241                 }
 242             }
 243             state->last_pts = buf_ps->start;
 244         }
 245     }
 246
 247     hb_buffer_t *buf = hb_buffer_init( buf_ps->alloc );
 248     hb_buffer_swap_copy( buf_ps, buf );
 249     hb_list_add( list_es, buf );
 250
 251     return 1;
 252 }
 253
 254 // "null" demuxer (makes a copy of input buf & returns it in list)
 255 // used when the reader for some format includes its own demuxer.
 256 // for example, ffmpeg.
 257 int hb_demux_null( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
 258 {
 259     // if we don't have a time offset yet, use this timestamp as the offset.
 260     if ( state && state->scr_changes == 0 &&
 261          ( buf_ps->start >= 0 || buf_ps->renderOffset >= 0 ) )
 262     {
 263         ++state->scr_changes;
 264         state->last_scr = buf_ps->start >= 0 ? buf_ps->start : buf_ps->renderOffset;
 265     }
 266
 267     hb_buffer_t *buf = hb_buffer_init( buf_ps->alloc );
 268     hb_buffer_swap_copy( buf_ps, buf );
 269     hb_list_add( list_es, buf );
 270
 271     return 1;
 272 }
 273
 274 const hb_muxer_t hb_demux[] = { hb_demux_ps, hb_demux_ts, hb_demux_null };