git.sesse.net Git - vlc/blob - include/input_ext-dec.h

   1 /*****************************************************************************
   2  * input_ext-dec.h: structures exported to the VideoLAN decoders
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id: input_ext-dec.h,v 1.67 2002/08/07 00:29:36 sam Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *          Michel Kaempf <maxx@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #ifndef _VLC_INPUT_EXT_DEC_H
  26 #define _VLC_INPUT_EXT_DEC_H 1
  27
  28 /* ES streams types - see ISO/IEC 13818-1 table 2-29 numbers.
  29  * these values are used in src/input/mpeg_system.c, and in
  30  * the following plugins: mpeg_ts, mpeg_ts_dvbpsi, input_satellite. */
  31 #define MPEG1_VIDEO_ES      0x01
  32 #define MPEG2_VIDEO_ES      0x02
  33 #define MPEG1_AUDIO_ES      0x03
  34 #define MPEG2_AUDIO_ES      0x04
  35 #define A52_AUDIO_ES        0x81
  36 /* These ones might violate the norm : */
  37 #define DVD_SPU_ES          0x82
  38 #define LPCM_AUDIO_ES       0x83
  39
  40 /* Structures exported to the decoders */
  41
  42 /*****************************************************************************
  43  * data_packet_t
  44  *****************************************************************************
  45  * Describe a data packet.
  46  *****************************************************************************/
  47 struct data_packet_t
  48 {
  49     /* Used to chain the packets that carry data for a same PES or PSI */
  50     data_packet_t *  p_next;
  51
  52     /* start of the PS or TS packet */
  53     byte_t *         p_demux_start;
  54     /* start of the PES payload in this packet */
  55     byte_t *         p_payload_start;
  56     byte_t *         p_payload_end; /* guess ? :-) */
  57     /* is the packet messed up ? */
  58     vlc_bool_t       b_discard_payload;
  59
  60     /* pointer to the real data */
  61     data_buffer_t *  p_buffer;
  62 };
  63
  64 /*****************************************************************************
  65  * pes_packet_t
  66  *****************************************************************************
  67  * Describes an PES packet, with its properties, and pointers to the TS packets
  68  * containing it.
  69  *****************************************************************************/
  70 struct pes_packet_t
  71 {
  72     /* Chained list to the next PES packet (depending on the context) */
  73     pes_packet_t *  p_next;
  74
  75     /* PES properties */
  76     vlc_bool_t      b_data_alignment;          /* used to find the beginning of
  77                                                 * a video or audio unit */
  78     vlc_bool_t      b_discontinuity;          /* This packet doesn't follow the
  79                                                * previous one */
  80
  81     mtime_t         i_pts;            /* PTS for this packet (zero if unset) */
  82     mtime_t         i_dts;            /* DTS for this packet (zero if unset) */
  83     int             i_rate;   /* current reading pace (see stream_control.h) */
  84
  85     unsigned int    i_pes_size;            /* size of the current PES packet */
  86
  87     /* Chained list to packets */
  88     data_packet_t * p_first;              /* The first packet contained by this
  89                                            * PES (used by decoders). */
  90     data_packet_t * p_last;            /* The last packet contained by this
  91                                         * PES (used by the buffer allocator) */
  92     unsigned int    i_nb_data; /* Number of data packets in the chained list */
  93 };
  94
  95 /*****************************************************************************
  96  * decoder_fifo_t
  97  *****************************************************************************
  98  * This rotative FIFO contains PES packets that are to be decoded.
  99  *****************************************************************************/
 100 struct decoder_fifo_t
 101 {
 102     VLC_COMMON_MEMBERS
 103
 104     /* Thread structures */
 105     vlc_mutex_t         data_lock;                         /* fifo data lock */
 106     vlc_cond_t          data_wait;         /* fifo data conditional variable */
 107
 108     /* Data */
 109     pes_packet_t *      p_first;
 110     pes_packet_t **     pp_last;
 111     int                 i_depth;       /* number of PES packets in the stack */
 112
 113     /* Communication interface between input and decoders */
 114     input_buffers_t    *p_packets_mgt;   /* packets management services data */
 115
 116     /* Standard pointers given to the decoders as a toolbox. */
 117     u16                 i_id;
 118     vlc_fourcc_t        i_fourcc;
 119     es_sys_t *          p_demux_data;
 120     stream_ctrl_t *     p_stream_ctrl;
 121
 122     /* Module properties */
 123     module_t *              p_module;
 124     int                 ( * pf_run ) ( decoder_fifo_t * );
 125 };
 126
 127 /*****************************************************************************
 128  * bit_fifo_t : bit fifo descriptor
 129  *****************************************************************************
 130  * This type describes a bit fifo used to store bits while working with the
 131  * input stream at the bit level.
 132  *****************************************************************************/
 133 typedef u32         WORD_TYPE;
 134
 135 typedef struct bit_fifo_t
 136 {
 137     /* This unsigned integer allows us to work at the bit level. This buffer
 138      * can contain 32 bits, and the used space can be found on the MSb's side
 139      * and the available space on the LSb's side. */
 140     WORD_TYPE           buffer;
 141
 142     /* Number of bits available in the bit buffer */
 143     int                 i_available;
 144
 145 } bit_fifo_t;
 146
 147 /*****************************************************************************
 148  * bit_stream_t : bit stream descriptor
 149  *****************************************************************************
 150  * This type, based on a PES stream, includes all the structures needed to
 151  * handle the input stream like a bit stream.
 152  *****************************************************************************/
 153 struct bit_stream_t
 154 {
 155     /*
 156      * Bit structures
 157      */
 158     bit_fifo_t       fifo;
 159
 160     /*
 161      * Input structures
 162      */
 163     /* The decoder fifo contains the data of the PES stream */
 164     decoder_fifo_t * p_decoder_fifo;
 165
 166     /* Callback to the decoder used when changing data packets ; set
 167      * to NULL if your decoder doesn't need it. */
 168     void          (* pf_bitstream_callback)( bit_stream_t *, vlc_bool_t );
 169     /* Optional argument to the callback */
 170     void *           p_callback_arg;
 171
 172     /*
 173      * PTS retrieval
 174      */
 175     mtime_t          i_pts, i_dts;
 176     byte_t *         p_pts_validity;
 177
 178     /*
 179      * Byte structures
 180      */
 181     /* Current data packet (in the current PES packet of the PES stream) */
 182     data_packet_t *         p_data;
 183     /* Pointer to the next byte that is to be read (in the current packet) */
 184     byte_t *                p_byte;
 185     /* Pointer to the last byte that is to be read (in the current packet */
 186     byte_t *                p_end;
 187     /* Temporary buffer in case we're not aligned when changing data packets */
 188     WORD_TYPE               i_showbits_buffer;
 189     data_packet_t           showbits_data;
 190 };
 191
 192 /*****************************************************************************
 193  * Inline functions used by the decoders to read bit_stream_t
 194  *****************************************************************************/
 195
 196 /*
 197  * DISCUSSION : How to use the bit_stream structures
 198  *
 199  * sizeof(WORD_TYPE) (usually 32) bits are read at the same time, thus
 200  * minimizing the number of p_byte changes.
 201  * Bits are read via GetBits() or ShowBits.
 202  *
 203  * XXX : Be aware that if, in the forthcoming functions, i_bits > 24,
 204  * the data have to be already aligned on an 8-bit boundary, or wrong
 205  * results will be returned. Use RealignBits() if unsure.
 206  */
 207
 208 #if (WORD_TYPE == u32)
 209 #   define WORD_AT      U32_AT
 210 #   define WORD_SIGNED  s32
 211 #elif (WORD_TYPE == u64)
 212 #   define WORD_AT      U64_AT
 213 #   define WORD_SIGNED  s64
 214 #else
 215 #   error Unsupported WORD_TYPE
 216 #endif
 217
 218 /*****************************************************************************
 219  * Prototypes from input_ext-dec.c
 220  *****************************************************************************/
 221 VLC_EXPORT( void, InitBitstream,  ( bit_stream_t *, decoder_fifo_t *, void ( * )( bit_stream_t *, vlc_bool_t ), void * p_callback_arg ) );
 222 VLC_EXPORT( vlc_bool_t, NextDataPacket,    ( decoder_fifo_t *, data_packet_t ** ) );
 223 VLC_EXPORT( void, BitstreamNextDataPacket, ( bit_stream_t * ) );
 224 VLC_EXPORT( u32,  UnalignedShowBits,       ( bit_stream_t *, unsigned int ) );
 225 VLC_EXPORT( void, UnalignedRemoveBits,     ( bit_stream_t * ) );
 226 VLC_EXPORT( u32,  UnalignedGetBits,        ( bit_stream_t *, unsigned int ) );
 227 VLC_EXPORT( void, CurrentPTS,              ( bit_stream_t *, mtime_t *, mtime_t * ) );
 228
 229 /*****************************************************************************
 230  * AlignWord : fill in the bit buffer so that the byte pointer be aligned
 231  * on a word boundary (XXX: there must be at least sizeof(WORD_TYPE) - 1
 232  * empty bytes in the bit buffer)
 233  *****************************************************************************/
 234 static inline void AlignWord( bit_stream_t * p_bit_stream )
 235 {
 236     while( (ptrdiff_t)p_bit_stream->p_byte
 237              & (sizeof(WORD_TYPE) - 1) )
 238     {
 239         if( p_bit_stream->p_byte < p_bit_stream->p_end )
 240         {
 241             p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
 242                 << (8 * sizeof(WORD_TYPE) - 8
 243                      - p_bit_stream->fifo.i_available);
 244             p_bit_stream->fifo.i_available += 8;
 245         }
 246         else
 247         {
 248             BitstreamNextDataPacket( p_bit_stream );
 249             p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
 250                 << (8 * sizeof(WORD_TYPE) - 8
 251                      - p_bit_stream->fifo.i_available);
 252             p_bit_stream->fifo.i_available += 8;
 253         }
 254     }
 255 }
 256
 257 /*****************************************************************************
 258  * ShowBits : return i_bits bits from the bit stream
 259  *****************************************************************************/
 260 static inline u32 ShowBits( bit_stream_t * p_bit_stream, unsigned int i_bits )
 261 {
 262     if( p_bit_stream->fifo.i_available >= i_bits )
 263     {
 264         return( p_bit_stream->fifo.buffer >> (8 * sizeof(WORD_TYPE) - i_bits) );
 265     }
 266
 267     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 268     {
 269         return( (p_bit_stream->fifo.buffer |
 270                     (WORD_AT( p_bit_stream->p_byte )
 271                         >> p_bit_stream->fifo.i_available))
 272                     >> (8 * sizeof(WORD_TYPE) - i_bits) );
 273     }
 274
 275     return( UnalignedShowBits( p_bit_stream, i_bits ) );
 276 }
 277
 278 /*****************************************************************************
 279  * ShowSignedBits : return i_bits bits from the bit stream, using signed
 280  *                  arithmetic
 281  *****************************************************************************/
 282 static inline s32 ShowSignedBits( bit_stream_t * p_bit_stream,
 283                                   unsigned int i_bits )
 284 {
 285     if( p_bit_stream->fifo.i_available >= i_bits )
 286     {
 287         return( (WORD_SIGNED)p_bit_stream->fifo.buffer
 288                     >> (8 * sizeof(WORD_TYPE) - i_bits) );
 289     }
 290
 291     /* You can probably do something a little faster, but now I'm tired. */
 292     return( (WORD_SIGNED)(ShowBits( p_bit_stream, i_bits ) << (32 - i_bits))
 293              >> (32 - i_bits) );
 294 }
 295
 296 /*****************************************************************************
 297  * RemoveBits : removes i_bits bits from the bit buffer
 298  *              XXX: do not use for 32 bits, see RemoveBits32
 299  *****************************************************************************/
 300 static inline void RemoveBits( bit_stream_t * p_bit_stream,
 301                                unsigned int i_bits )
 302 {
 303     p_bit_stream->fifo.i_available -= i_bits;
 304
 305     if( p_bit_stream->fifo.i_available >= 0 )
 306     {
 307         p_bit_stream->fifo.buffer <<= i_bits;
 308         return;
 309     }
 310
 311     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 312     {
 313         p_bit_stream->fifo.buffer = WORD_AT( p_bit_stream->p_byte )
 314                                         << ( -p_bit_stream->fifo.i_available );
 315         ((WORD_TYPE *)p_bit_stream->p_byte)++;
 316         p_bit_stream->fifo.i_available += sizeof(WORD_TYPE) * 8;
 317         return;
 318     }
 319
 320     UnalignedRemoveBits( p_bit_stream );
 321 }
 322
 323 /*****************************************************************************
 324  * RemoveBits32 : removes 32 bits from the bit buffer (and as a side effect,
 325  *                refill it)
 326  *****************************************************************************/
 327 #if (WORD_TYPE == u32)
 328 static inline void RemoveBits32( bit_stream_t * p_bit_stream )
 329 {
 330     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 331     {
 332         if( p_bit_stream->fifo.i_available )
 333         {
 334             p_bit_stream->fifo.buffer = WORD_AT( p_bit_stream->p_byte )
 335                             << (32 - p_bit_stream->fifo.i_available);
 336             ((WORD_TYPE *)p_bit_stream->p_byte)++;
 337             return;
 338         }
 339
 340         ((WORD_TYPE *)p_bit_stream->p_byte)++;
 341         return;
 342     }
 343
 344     p_bit_stream->fifo.i_available -= 32;
 345     UnalignedRemoveBits( p_bit_stream );
 346 }
 347 #else
 348 #   define RemoveBits32( p_bit_stream )     RemoveBits( p_bit_stream, 32 )
 349 #endif
 350
 351 /*****************************************************************************
 352  * GetBits : returns i_bits bits from the bit stream and removes them
 353  *           XXX: do not use for 32 bits, see GetBits32
 354  *****************************************************************************/
 355 static inline u32 GetBits( bit_stream_t * p_bit_stream, unsigned int i_bits )
 356 {
 357     u32             i_result;
 358
 359     p_bit_stream->fifo.i_available -= i_bits;
 360
 361     if( p_bit_stream->fifo.i_available >= 0 )
 362     {
 363         i_result = p_bit_stream->fifo.buffer
 364                         >> (8 * sizeof(WORD_TYPE) - i_bits);
 365         p_bit_stream->fifo.buffer <<= i_bits;
 366         return( i_result );
 367     }
 368
 369     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 370     {
 371         i_result = p_bit_stream->fifo.buffer
 372                         >> (8 * sizeof(WORD_TYPE) - i_bits);
 373         p_bit_stream->fifo.buffer = WORD_AT( p_bit_stream->p_byte );
 374         ((WORD_TYPE *)p_bit_stream->p_byte)++;
 375         i_result |= p_bit_stream->fifo.buffer
 376                         >> (8 * sizeof(WORD_TYPE)
 377                                      + p_bit_stream->fifo.i_available);
 378         p_bit_stream->fifo.buffer <<= ( -p_bit_stream->fifo.i_available );
 379         p_bit_stream->fifo.i_available += sizeof(WORD_TYPE) * 8;
 380         return( i_result );
 381     }
 382
 383     return UnalignedGetBits( p_bit_stream, i_bits );
 384 }
 385
 386 /*****************************************************************************
 387  * GetSignedBits : returns i_bits bits from the bit stream and removes them,
 388  *                 using signed arithmetic
 389  *                 XXX: do not use for 32 bits
 390  *****************************************************************************/
 391 static inline s32 GetSignedBits( bit_stream_t * p_bit_stream,
 392                                  unsigned int i_bits )
 393 {
 394     if( p_bit_stream->fifo.i_available >= i_bits )
 395     {
 396         s32             i_result;
 397
 398         p_bit_stream->fifo.i_available -= i_bits;
 399         i_result = (WORD_SIGNED)p_bit_stream->fifo.buffer
 400                         >> (8 * sizeof(WORD_TYPE) - i_bits);
 401         p_bit_stream->fifo.buffer <<= i_bits;
 402         return( i_result );
 403     }
 404
 405     /* You can probably do something a little faster, but now I'm tired. */
 406     return( (WORD_SIGNED)(GetBits( p_bit_stream, i_bits ) << (32 - i_bits))
 407              >> (32 - i_bits) );
 408 }
 409
 410 /*****************************************************************************
 411  * GetBits32 : returns 32 bits from the bit stream and removes them
 412  *****************************************************************************/
 413 #if (WORD_TYPE == u32)
 414 static inline u32 GetBits32( bit_stream_t * p_bit_stream )
 415 {
 416     u32             i_result;
 417
 418     if( p_bit_stream->fifo.i_available == 32 )
 419     {
 420         p_bit_stream->fifo.i_available = 0;
 421         i_result = p_bit_stream->fifo.buffer;
 422         p_bit_stream->fifo.buffer = 0;
 423         return( i_result );
 424     }
 425
 426     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 427     {
 428         if( p_bit_stream->fifo.i_available )
 429         {
 430             i_result = p_bit_stream->fifo.buffer;
 431             p_bit_stream->fifo.buffer = WORD_AT( p_bit_stream->p_byte );
 432             ((WORD_TYPE *)p_bit_stream->p_byte)++;
 433             i_result |= p_bit_stream->fifo.buffer
 434                              >> (p_bit_stream->fifo.i_available);
 435             p_bit_stream->fifo.buffer <<= (32 - p_bit_stream->fifo.i_available);
 436             return( i_result );
 437         }
 438
 439         i_result = WORD_AT( p_bit_stream->p_byte );
 440         ((WORD_TYPE *)p_bit_stream->p_byte)++;
 441         return( i_result );
 442     }
 443
 444     p_bit_stream->fifo.i_available -= 32;
 445     return UnalignedGetBits( p_bit_stream, 32 );
 446 }
 447 #else
 448 #   define GetBits32( p_bit_stream )    GetBits( p_bit_stream, 32 )
 449 #endif
 450
 451 /*****************************************************************************
 452  * RealignBits : realigns the bit buffer on an 8-bit boundary
 453  *****************************************************************************/
 454 static inline void RealignBits( bit_stream_t * p_bit_stream )
 455 {
 456     p_bit_stream->fifo.buffer <<= (p_bit_stream->fifo.i_available & 0x7);
 457     p_bit_stream->fifo.i_available &= ~0x7;
 458 }
 459
 460
 461 /*****************************************************************************
 462  * GetChunk : reads a large chunk of data
 463  *****************************************************************************
 464  * The position in the stream must be byte-aligned, if unsure call
 465  * RealignBits(). p_buffer must point to a buffer at least as big as i_buf_len
 466  * otherwise your code will crash.
 467  *****************************************************************************/
 468 static inline void GetChunk( bit_stream_t * p_bit_stream,
 469                              byte_t * p_buffer, size_t i_buf_len )
 470 {
 471     ptrdiff_t           i_available;
 472
 473     /* We need to take care because i_buf_len may be < 4. */
 474     while( p_bit_stream->fifo.i_available > 0 && i_buf_len )
 475     {
 476         *p_buffer = p_bit_stream->fifo.buffer >> (8 * sizeof(WORD_TYPE) - 8);
 477         p_buffer++;
 478         i_buf_len--;
 479         p_bit_stream->fifo.buffer <<= 8;
 480         p_bit_stream->fifo.i_available -= 8;
 481     }
 482
 483     if( (i_available = p_bit_stream->p_end - p_bit_stream->p_byte)
 484             >= i_buf_len )
 485     {
 486         p_bit_stream->p_decoder_fifo->p_vlc->pf_memcpy( p_buffer,
 487                                            p_bit_stream->p_byte, i_buf_len );
 488         p_bit_stream->p_byte += i_buf_len;
 489     }
 490     else
 491     {
 492         do
 493         {
 494             p_bit_stream->p_decoder_fifo->p_vlc->pf_memcpy( p_buffer,
 495                                            p_bit_stream->p_byte, i_available );
 496             p_bit_stream->p_byte = p_bit_stream->p_end;
 497             p_buffer += i_available;
 498             i_buf_len -= i_available;
 499             BitstreamNextDataPacket( p_bit_stream );
 500             if( p_bit_stream->p_decoder_fifo->b_die )
 501                 return;
 502         }
 503         while( (i_available = p_bit_stream->p_end - p_bit_stream->p_byte)
 504                 <= i_buf_len );
 505
 506         if( i_buf_len )
 507         {
 508             p_bit_stream->p_decoder_fifo->p_vlc->pf_memcpy( p_buffer,
 509                                            p_bit_stream->p_byte, i_buf_len );
 510             p_bit_stream->p_byte += i_buf_len;
 511         }
 512     }
 513
 514     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 515     {
 516         AlignWord( p_bit_stream );
 517     }
 518 }
 519
 520
 521 /*
 522  * Communication interface between input and decoders
 523  */
 524
 525 /*****************************************************************************
 526  * Prototypes from input_dec.c
 527  *****************************************************************************/
 528 VLC_EXPORT( void, DecoderError, ( decoder_fifo_t * p_fifo ) );
 529
 530 #endif /* "input_ext-dec.h" */