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     }
  43     state->last_scr = scr;
  44 }
  45
  46 /* Basic MPEG demuxer */
  47
  48 int hb_demux_ps( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
  49 {
  50     hb_buffer_t * buf_es;
  51     int           pos = 0;
  52
  53 #define d (buf_ps->data)
  54
  55     /* pack_header */
  56     if( d[pos] != 0 || d[pos+1] != 0 ||
  57         d[pos+2] != 0x1 || d[pos+3] != 0xBA )
  58     {
  59         hb_log( "hb_demux_ps: not a PS packet (%02x%02x%02x%02x)",
  60                 d[pos], d[pos+1], d[pos+2], d[pos+3] );
  61         return 0;
  62     }
  63     pos += 4;                    /* pack_start_code */
  64
  65     if ( state )
  66     {
  67         /* extract the system clock reference (scr) */
  68         int64_t scr = ((uint64_t)(d[pos] & 0x38) << 27) |
  69                       ((uint64_t)(d[pos] & 0x03) << 28) |
  70                       ((uint64_t)(d[pos+1]) << 20) |
  71                       ((uint64_t)(d[pos+2] >> 3) << 15) |
  72                       ((uint64_t)(d[pos+2] & 3) << 13) |
  73                       ((uint64_t)(d[pos+3]) << 5) |
  74                       (d[pos+4] >> 3);
  75         check_mpeg_scr( state, scr, 100 );
  76     }
  77
  78     pos += 9;                    /* pack_header */
  79     pos += 1 + ( d[pos] & 0x7 ); /* stuffing bytes */
  80
  81     /* system_header */
  82     if( d[pos] == 0 && d[pos+1] == 0 &&
  83         d[pos+2] == 0x1 && d[pos+3] == 0xBB )
  84     {
  85         int header_length;
  86
  87         pos           += 4; /* system_header_start_code */
  88         header_length  = ( d[pos] << 8 ) + d[pos+1];
  89         pos           += 2 + header_length;
  90     }
  91
  92     /* pes */
  93     while( pos + 6 < buf_ps->size &&
  94            d[pos] == 0 && d[pos+1] == 0 && d[pos+2] == 0x1 )
  95     {
  96         int      id;
  97         int      pes_packet_length;
  98         int      pes_packet_end;
  99         int      pes_header_d_length;
 100         int      pes_header_end;
 101         int      has_pts;
 102         int64_t  pts = -1, dts = -1;
 103
 104         pos               += 3;               /* packet_start_code_prefix */
 105         id           = d[pos];
 106         pos               += 1;
 107
 108         pes_packet_length  = ( d[pos] << 8 ) + d[pos+1];
 109         pos               += 2;               /* pes_packet_length */
 110         pes_packet_end     = pos + pes_packet_length;
 111
 112         if( id != 0xE0 && id != 0xBD &&
 113             ( id & 0xC0 ) != 0xC0  )
 114         {
 115             /* Not interesting */
 116             pos = pes_packet_end;
 117             continue;
 118         }
 119
 120         has_pts            = d[pos+1] >> 6;
 121         pos               += 2;               /* Required headers */
 122
 123         pes_header_d_length  = d[pos];
 124         pos                    += 1;
 125         pes_header_end          = pos + pes_header_d_length;
 126
 127         if( has_pts )
 128         {
 129             pts = ( (uint64_t)(d[pos] & 0xe ) << 29 ) +
 130                   ( d[pos+1] << 22 ) +
 131                   ( ( d[pos+2] >> 1 ) << 15 ) +
 132                   ( d[pos+3] << 7 ) +
 133                   ( d[pos+4] >> 1 );
 134             if ( has_pts & 1 )
 135             {
 136                 dts = ( (uint64_t)(d[pos+5] & 0xe ) << 29 ) +
 137                       ( d[pos+6] << 22 ) +
 138                       ( ( d[pos+7] >> 1 ) << 15 ) +
 139                       ( d[pos+8] << 7 ) +
 140                       ( d[pos+9] >> 1 );
 141             }
 142             else
 143             {
 144                 dts = pts;
 145             }
 146             if ( state && state->flaky_clock )
 147             {
 148                 // Program streams have an SCR in every PACK header so they
 149                 // can't lose their clock reference. But the PCR in Transport
 150                 // streams is typically on <.1% of the packets. If a PCR
 151                 // packet gets lost and it marks a clock discontinuity then
 152                 // the data following it will be referenced to the wrong
 153                 // clock & introduce huge gaps or throw our A/V sync off.
 154                 // We try to protect against that here by sanity checking
 155                 // timestamps against the current reference clock and discarding
 156                 // packets where the DTS is "too far" from its clock.
 157                 int64_t fdelta = dts - state->last_scr;
 158                 if ( fdelta < -300 * 90000LL || fdelta > 300 * 90000LL )
 159                 {
 160                     // packet too far behind or ahead of its clock reference
 161                     ++state->dts_drops;
 162                     pos = pes_packet_end;
 163                     continue;
 164                 }
 165             }
 166         }
 167
 168         pos = pes_header_end;
 169
 170         if( id == 0xBD )
 171         {
 172             id |= ( d[pos] << 8 );
 173             if( ( id & 0xF0FF ) == 0x80BD ) /* A52 */
 174             {
 175                 pos += 4;
 176             }
 177             else if( ( id & 0xE0FF ) == 0x20BD || /* SPU */
 178                      ( id & 0xF0FF ) == 0xA0BD )  /* LPCM */
 179             {
 180                 pos += 1;
 181             }
 182         }
 183
 184         /* Sanity check */
 185         if( pos >= pes_packet_end )
 186         {
 187             pos = pes_packet_end;
 188             continue;
 189         }
 190
 191         /* Here we hit we ES payload */
 192         buf_es = hb_buffer_init( pes_packet_end - pos );
 193
 194         buf_es->id       = id;
 195         buf_es->start    = pts;
 196         buf_es->renderOffset = dts;
 197         buf_es->stop     = -1;
 198         if (id == 0xE0) {
 199             // Consume a chapter break, and apply it to the ES.
 200             buf_es->new_chap = buf_ps->new_chap;
 201             buf_ps->new_chap = 0;
 202         }
 203         memcpy( buf_es->data, d + pos, pes_packet_end - pos );
 204
 205         hb_list_add( list_es, buf_es );
 206
 207         pos = pes_packet_end;
 208     }
 209
 210 #undef d
 211
 212     return 1;
 213 }
 214
 215 // mpeg transport stream demuxer. the elementary stream headers have been
 216 // stripped off and buf_ps has all the info gleaned from them: id is set,
 217 // start contains the pts (if any), renderOffset contains the dts (if any)
 218 // and stop contains the pcr (if it changed).
 219 int hb_demux_ts( hb_buffer_t *buf_ps, hb_list_t *list_es, hb_psdemux_t *state )
 220 {
 221     if ( state )
 222     {
 223         // we're keeping track of timing (i.e., not in scan)
 224         // check if there's a new pcr in this packet
 225         if ( buf_ps->stop >= 0 )
 226         {
 227             // we have a new pcr
 228             check_mpeg_scr( state, buf_ps->stop, 300 );
 229             buf_ps->stop = -1;
 230         }
 231         if ( buf_ps->renderOffset >= 0 )
 232         {
 233             // Program streams have an SCR in every PACK header so they
 234             // can't lose their clock reference. But the PCR in Transport
 235             // streams is typically on <.1% of the packets. If a PCR
 236             // packet gets lost and it marks a clock discontinuity then
 237             // the data following it will be referenced to the wrong
 238             // clock & introduce huge gaps or throw our A/V sync off.
 239             // We try to protect against that here by sanity checking
 240             // timestamps against the current reference clock and discarding
 241             // packets where the DTS is "too far" from its clock.
 242             int64_t fdelta = buf_ps->renderOffset - state->last_scr;
 243             if ( fdelta < -300 * 90000LL || fdelta > 300 * 90000LL )
 244             {
 245                 // packet too far behind or ahead of its clock reference
 246                 ++state->dts_drops;
 247                 return 1;
 248             }
 249         }
 250     }
 251
 252     hb_buffer_t *buf = hb_buffer_init( buf_ps->alloc );
 253     hb_buffer_swap_copy( buf_ps, buf );
 254     hb_list_add( list_es, buf );
 255
 256     return 1;
 257 }
 258
 259 // "null" demuxer (makes a copy of input buf & returns it in list)
 260 // used when the reader for some format includes its own demuxer.
 261 // for example, ffmpeg.
 262 int hb_demux_null( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
 263 {
 264     // if we don't have a time offset yet, use this timestamp as the offset.
 265     if ( state && state->scr_changes == 0 &&
 266          ( buf_ps->start >= 0 || buf_ps->renderOffset >= 0 ) )
 267     {
 268         ++state->scr_changes;
 269         state->last_scr = buf_ps->start >= 0 ? buf_ps->start : buf_ps->renderOffset;
 270     }
 271
 272     hb_buffer_t *buf = hb_buffer_init( buf_ps->alloc );
 273     hb_buffer_swap_copy( buf_ps, buf );
 274     hb_list_add( list_es, buf );
 275
 276     return 1;
 277 }
 278
 279 const hb_muxer_t hb_demux[] = { hb_demux_ps, hb_demux_ts, hb_demux_null };