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

   1 /*****************************************************************************
   2  * input_ext-dec.c: services to the decoders
   3  *****************************************************************************
   4  * Copyright (C) 1998, 1999, 2000 VideoLAN
   5  *
   6  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #include "defs.h"
  27
  28 #include "config.h"
  29 #include "common.h"
  30 #include "threads.h"
  31 #include "mtime.h"
  32
  33 #include "intf_msg.h"
  34
  35 #include "stream_control.h"
  36 #include "input_ext-dec.h"
  37 #include "input_ext-intf.h"
  38
  39 #include "input.h"
  40
  41 /*****************************************************************************
  42  * InitBitstream: initialize a bit_stream_t structure
  43  *****************************************************************************/
  44 void InitBitstream( bit_stream_t * p_bit_stream, decoder_fifo_t * p_fifo )
  45 {
  46     p_bit_stream->p_decoder_fifo = p_fifo;
  47     p_bit_stream->pf_next_data_packet = NextDataPacket;
  48     p_bit_stream->pf_bitstream_callback = NULL;
  49     p_bit_stream->p_callback_arg = NULL;
  50
  51     /* Get the first data packet. */
  52     vlc_mutex_lock( &p_fifo->data_lock );
  53     while ( DECODER_FIFO_ISEMPTY( *p_fifo ) )
  54     {
  55         if ( p_fifo->b_die )
  56         {
  57             vlc_mutex_unlock( &p_fifo->data_lock );
  58             return;
  59         }
  60         vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock );
  61     }
  62     p_bit_stream->p_data = DECODER_FIFO_START( *p_fifo )->p_first;
  63     p_bit_stream->p_byte = p_bit_stream->p_data->p_payload_start;
  64     p_bit_stream->p_end  = p_bit_stream->p_data->p_payload_end;
  65     p_bit_stream->fifo.buffer = 0;
  66     p_bit_stream->fifo.i_available = 0;
  67     vlc_mutex_unlock( &p_fifo->data_lock );
  68
  69     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
  70     {
  71         /* Get aligned on a word boundary.
  72          * NB : we _will_ get aligned, because we have at most
  73          * sizeof(WORD_TYPE) - 1 bytes to store, and at least
  74          * sizeof(WORD_TYPE) - 1 empty bytes in the bit buffer. */
  75         AlignWord( p_bit_stream );
  76     }
  77 }
  78
  79 /*****************************************************************************
  80  * NextDataPacket: go to the next data packet
  81  *****************************************************************************/
  82 void NextDataPacket( bit_stream_t * p_bit_stream )
  83 {
  84     decoder_fifo_t *    p_fifo = p_bit_stream->p_decoder_fifo;
  85     boolean_t           b_new_pes;
  86
  87     /* We are looking for the next data packet that contains real data,
  88      * and not just a PES header */
  89     do
  90     {
  91         /* We were reading the last data packet of this PES packet... It's
  92          * time to jump to the next PES packet */
  93         if( p_bit_stream->p_data->p_next == NULL )
  94         {
  95             /* We are going to read/write the start and end indexes of the
  96              * decoder fifo and to use the fifo's conditional variable,
  97              * that's why we need to take the lock before. */
  98             vlc_mutex_lock( &p_fifo->data_lock );
  99
 100             /* Free the previous PES packet. */
 101             p_fifo->pf_delete_pes( p_fifo->p_packets_mgt,
 102                                    DECODER_FIFO_START( *p_fifo ) );
 103             DECODER_FIFO_INCSTART( *p_fifo );
 104
 105             if( DECODER_FIFO_ISEMPTY( *p_fifo ) )
 106             {
 107                 /* Wait for the input to tell us when we receive a packet. */
 108                 vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock );
 109             }
 110
 111             /* The next byte could be found in the next PES packet */
 112             p_bit_stream->p_data = DECODER_FIFO_START( *p_fifo )->p_first;
 113
 114             vlc_mutex_unlock( &p_fifo->data_lock );
 115
 116             b_new_pes = 1;
 117         }
 118         else
 119         {
 120             /* Perhaps the next data packet of the current PES packet contains
 121              * real data (ie its payload's size is greater than 0). */
 122             p_bit_stream->p_data = p_bit_stream->p_data->p_next;
 123
 124             b_new_pes = 0;
 125         }
 126     } while ( p_bit_stream->p_data->p_payload_start
 127                == p_bit_stream->p_data->p_payload_end );
 128
 129     /* We've found a data packet which contains interesting data... */
 130     p_bit_stream->p_byte = p_bit_stream->p_data->p_payload_start;
 131     p_bit_stream->p_end  = p_bit_stream->p_data->p_payload_end;
 132
 133     /* Call back the decoder. */
 134     if( p_bit_stream->pf_bitstream_callback != NULL )
 135     {
 136         p_bit_stream->pf_bitstream_callback( p_bit_stream, b_new_pes );
 137     }
 138 }
 139
 140 /*****************************************************************************
 141  * UnalignedShowBits : return i_bits bits from the bit stream, even when
 142  * not aligned on a word boundary
 143  *****************************************************************************/
 144 u32 UnalignedShowBits( bit_stream_t * p_bit_stream, unsigned int i_bits )
 145 {
 146     /* We just fill in the bit buffer. */
 147     while( p_bit_stream->fifo.i_available < i_bits )
 148     {
 149         if( p_bit_stream->p_byte < p_bit_stream->p_end )
 150         {
 151             p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
 152                                             << (8 * sizeof(WORD_TYPE) - 8
 153                                             - p_bit_stream->fifo.i_available);
 154             p_bit_stream->fifo.i_available += 8;
 155         }
 156         else
 157         {
 158             p_bit_stream->pf_next_data_packet( p_bit_stream );
 159             p_bit_stream->fifo.buffer |= *(p_bit_stream->p_byte++)
 160                                             << (8 * sizeof(WORD_TYPE) - 8
 161                                             - p_bit_stream->fifo.i_available);
 162             p_bit_stream->fifo.i_available += 8;
 163         }
 164     }
 165     return( p_bit_stream->fifo.buffer >> (8 * sizeof(WORD_TYPE) - i_bits) );
 166 }
 167
 168 /*****************************************************************************
 169  * UnalignedGetBits : returns i_bits bits from the bit stream and removes
 170  * them from the buffer, even when the bit stream is not aligned on a word
 171  * boundary
 172  *****************************************************************************/
 173 u32 UnalignedGetBits( bit_stream_t * p_bit_stream, unsigned int i_bits )
 174 {
 175     u32         i_result;
 176
 177     i_result = p_bit_stream->fifo.buffer
 178                     >> (8 * sizeof(WORD_TYPE) - i_bits);
 179     i_bits = -p_bit_stream->fifo.i_available;
 180
 181     /* Gather missing bytes. */
 182     while( i_bits >= 8 )
 183     {
 184         if( p_bit_stream->p_byte < p_bit_stream->p_end )
 185         {
 186             i_result |= *(p_bit_stream->p_byte++) << (i_bits - 8);
 187             i_bits -= 8;
 188         }
 189         else
 190         {
 191             p_bit_stream->pf_next_data_packet( p_bit_stream );
 192             i_result |= *(p_bit_stream->p_byte++) << (i_bits - 8);
 193             i_bits -= 8;
 194         }
 195     }
 196
 197     /* Gather missing bits. */
 198     if( i_bits > 0 )
 199     {
 200         unsigned int    i_tmp = 8 - i_bits;
 201
 202         if( p_bit_stream->p_byte < p_bit_stream->p_end )
 203         {
 204             i_result |= *p_bit_stream->p_byte >> i_tmp;
 205             p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
 206                  << ( sizeof(WORD_TYPE) * 8 - i_tmp );
 207             p_bit_stream->fifo.i_available = i_tmp;
 208         }
 209         else
 210         {
 211             p_bit_stream->pf_next_data_packet( p_bit_stream );
 212             i_result |= *p_bit_stream->p_byte >> i_tmp;
 213             p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
 214                  << ( sizeof(WORD_TYPE) * 8 - i_tmp );
 215             p_bit_stream->fifo.i_available = i_tmp;
 216         }
 217     }
 218     else
 219     {
 220         p_bit_stream->fifo.i_available = 0;
 221         p_bit_stream->fifo.buffer = 0;
 222     }
 223
 224     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 225     {
 226         /* Get aligned on a word boundary. Otherwise it is safer
 227          * to do it the next time.
 228          * NB : we _will_ get aligned, because we have at most
 229          * sizeof(WORD_TYPE) - 1 bytes to store, and at least
 230          * sizeof(WORD_TYPE) - 1 empty bytes in the bit buffer. */
 231         AlignWord( p_bit_stream );
 232     }
 233
 234     return( i_result );
 235 }
 236
 237 /*****************************************************************************
 238  * UnalignedRemoveBits : removes i_bits (== -i_available) from the bit
 239  * buffer, even when the bit stream is not aligned on a word boundary
 240  *****************************************************************************/
 241 void UnalignedRemoveBits( bit_stream_t * p_bit_stream )
 242 {
 243     /* First remove all unnecessary bytes. */
 244     while( p_bit_stream->fifo.i_available <= -8 )
 245     {
 246         if( p_bit_stream->p_byte < p_bit_stream->p_end )
 247         {
 248             p_bit_stream->p_byte++;
 249             p_bit_stream->fifo.i_available += 8;
 250         }
 251         else
 252         {
 253             p_bit_stream->pf_next_data_packet( p_bit_stream );
 254             p_bit_stream->p_byte++;
 255             p_bit_stream->fifo.i_available += 8;
 256         }
 257     }
 258
 259     /* Remove unnecessary bits. */
 260     if( p_bit_stream->fifo.i_available < 0 )
 261     {
 262         if( p_bit_stream->p_byte < p_bit_stream->p_end )
 263         {
 264             p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
 265                  << ( sizeof(WORD_TYPE) * 8 - 8
 266                          - p_bit_stream->fifo.i_available );
 267             p_bit_stream->fifo.i_available += 8;
 268         }
 269         else
 270         {
 271             p_bit_stream->pf_next_data_packet( p_bit_stream );
 272             p_bit_stream->fifo.buffer = *(p_bit_stream->p_byte++)
 273                  << ( sizeof(WORD_TYPE) * 8 - 8
 274                          - p_bit_stream->fifo.i_available );
 275             p_bit_stream->fifo.i_available += 8;
 276         }
 277     }
 278     else
 279     {
 280         p_bit_stream->fifo.buffer = 0;
 281     }
 282
 283     if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
 284     {
 285         /* Get aligned on a word boundary. Otherwise it is safer
 286          * to do it the next time.
 287          * NB : we _will_ get aligned, because we have at most
 288          * sizeof(WORD_TYPE) - 1 bytes to store, and at least
 289          * sizeof(WORD_TYPE) - 1 empty bytes in the bit buffer. */
 290         AlignWord( p_bit_stream );
 291     }
 292 }
 293