[svn] / trunk / xvidcore / src / bitstream / bitstream.h Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/bitstream/bitstream.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 136, Thu Apr 25 06:55:00 2002 UTC revision 2177, Sun Nov 3 11:50:49 2019 UTC
# Line 1  Line 1 
1   /******************************************************************************  /*****************************************************************************
2    *                                                                            *   *
3    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *   *  XVID MPEG-4 VIDEO CODEC
4    *                                                                            *   *  - Bitstream reader/writer inlined functions and constants-
5    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *   *
6    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *   *  Copyright (C) 2001-2003 Peter Ross <pross@xvid.org>
7    *  software module in hardware or software products are advised that its     *   *
8    *  use may infringe existing patents or copyrights, and any such use         *   *  This program is free software ; you can redistribute it and/or modify
9    *  would be at such party's own risk.  The original developer of this        *   *  it under the terms of the GNU General Public License as published by
10    *  software module and his/her company, and subsequent editors and their     *   *  the Free Software Foundation ; either version 2 of the License, or
11    *  companies, will have no liability for use of this software or             *   *  (at your option) any later version.
12    *  modifications or derivatives thereof.                                     *   *
13    *                                                                            *   *  This program is distributed in the hope that it will be useful,
14    *  XviD is free software; you can redistribute it and/or modify it           *   *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
15    *  under the terms of the GNU General Public License as published by         *   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    *  the Free Software Foundation; either version 2 of the License, or         *   *  GNU General Public License for more details.
17    *  (at your option) any later version.                                       *   *
18    *                                                                            *   *  You should have received a copy of the GNU General Public License
19    *  XviD is distributed in the hope that it will be useful, but               *   *  along with this program ; if not, write to the Free Software
20    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *   *
22    *  GNU General Public License for more details.                              *   * $Id$
23    *                                                                            *   *
24    *  You should have received a copy of the GNU General Public License         *   ****************************************************************************/
   *  along with this program; if not, write to the Free Software               *  
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                            *  
   *  bitstream.h                                                               *  
   *                                                                            *  
   *  Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au>                    *  
   *                                                                            *  
   *  For more information visit the XviD homepage: http://www.xvid.org         *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                                                                                                        *  
   *  Revision history:                                                         *  
   *                                                                            *  
   *  26.03.2002 interlacing support - modified putvol/vopheaders paramters  
   *  04.03.2002 putbits speedup (Isibaar)                                      *  
   *  03.03.2002 merged BITREADER and BITWRITER (Isibaar)                       *  
   *      16.12.2001     inital version                                                     *  
   *                                                                                                                                                        *  
   ******************************************************************************/  
25    
26  #ifndef _BITSTREAM_H_  #ifndef _BITSTREAM_H_
27  #define _BITSTREAM_H_  #define _BITSTREAM_H_
# Line 55  Line 30 
30  #include "../decoder.h"  #include "../decoder.h"
31  #include "../encoder.h"  #include "../encoder.h"
32    
33  // comment any #defs we dont use  
34    /*****************************************************************************
35     * Constants
36     ****************************************************************************/
37    
38    /* comment any #defs we dont use */
39    
40  #define VIDOBJ_START_CODE               0x00000100      /* ..0x0000011f  */  #define VIDOBJ_START_CODE               0x00000100      /* ..0x0000011f  */
41  #define VIDOBJLAY_START_CODE    0x00000120      /* ..0x0000012f */  #define VIDOBJLAY_START_CODE    0x00000120      /* ..0x0000012f */
# Line 63  Line 43 
43  #define VISOBJSEQ_STOP_CODE             0x000001b1      /* ??? */  #define VISOBJSEQ_STOP_CODE             0x000001b1      /* ??? */
44  #define USERDATA_START_CODE             0x000001b2  #define USERDATA_START_CODE             0x000001b2
45  #define GRPOFVOP_START_CODE             0x000001b3  #define GRPOFVOP_START_CODE             0x000001b3
46  //#define VIDSESERR_ERROR_CODE  0x000001b4  /*#define VIDSESERR_ERROR_CODE  0x000001b4 */
47  #define VISOBJ_START_CODE               0x000001b5  #define VISOBJ_START_CODE               0x000001b5
48  //#define SLICE_START_CODE              0x000001b7  #define VOP_START_CODE                  0x000001b6
49  //#define EXT_START_CODE                0x000001b8  /*#define STUFFING_START_CODE   0x000001c3 */
50    
51    
52  #define VISOBJ_TYPE_VIDEO                               1  #define VISOBJ_TYPE_VIDEO                               1
53  //#define VISOBJ_TYPE_STILLTEXTURE              2  /*#define VISOBJ_TYPE_STILLTEXTURE      2 */
54  //#define VISOBJ_TYPE_MESH                              3  /*#define VISOBJ_TYPE_MESH              3 */
55  //#define VISOBJ_TYPE_FBA                               4  /*#define VISOBJ_TYPE_FBA               4 */
56  //#define VISOBJ_TYPE_3DMESH                    5  /*#define VISOBJ_TYPE_3DMESH            5 */
57    
58    
59  #define VIDOBJLAY_TYPE_SIMPLE                   1  #define VIDOBJLAY_TYPE_SIMPLE                   1
60  //#define VIDOBJLAY_TYPE_SIMPLE_SCALABLE        2  /*#define VIDOBJLAY_TYPE_SIMPLE_SCALABLE    2 */
61  #define VIDOBJLAY_TYPE_CORE                             3  /*#define VIDOBJLAY_TYPE_CORE                           3 */
62  #define VIDOBJLAY_TYPE_MAIN                             4  /*#define VIDOBJLAY_TYPE_MAIN                           4 */
63    /*#define VIDOBJLAY_TYPE_NBIT                           5 */
64    /*#define VIDOBJLAY_TYPE_ANIM_TEXT                      6 */
65  //#define VIDOBJLAY_AR_SQUARE                   1  /*#define VIDOBJLAY_TYPE_ANIM_MESH                      7 */
66  //#define VIDOBJLAY_AR_625TYPE_43               2  /*#define VIDOBJLAY_TYPE_SIMPLE_FACE            8 */
67  //#define VIDOBJLAY_AR_525TYPE_43               3  /*#define VIDOBJLAY_TYPE_STILL_SCALABLE         9 */
68  //#define VIDOBJLAY_AR_625TYPE_169              8  #define VIDOBJLAY_TYPE_ART_SIMPLE               10
69  //#define VIDOBJLAY_AR_525TYPE_169              9  /*#define VIDOBJLAY_TYPE_CORE_SCALABLE          11 */
70    /*#define VIDOBJLAY_TYPE_ACE                            12 */
71    /*#define VIDOBJLAY_TYPE_ADVANCED_SCALABLE_TEXTURE 13 */
72    /*#define VIDOBJLAY_TYPE_SIMPLE_FBA                     14 */
73    /*#define VIDEOJLAY_TYPE_SIMPLE_STUDIO    15*/
74    /*#define VIDEOJLAY_TYPE_CORE_STUDIO      16*/
75    #define VIDOBJLAY_TYPE_ASP              17
76    /*#define VIDOBJLAY_TYPE_FGS              18*/
77    
78    
79    /*#define VIDOBJLAY_AR_SQUARE           1 */
80    /*#define VIDOBJLAY_AR_625TYPE_43       2 */
81    /*#define VIDOBJLAY_AR_525TYPE_43       3 */
82    /*#define VIDOBJLAY_AR_625TYPE_169      8 */
83    /*#define VIDOBJLAY_AR_525TYPE_169      9 */
84  #define VIDOBJLAY_AR_EXTPAR                             15  #define VIDOBJLAY_AR_EXTPAR                             15
85    
86    
# Line 95  Line 89 
89  #define VIDOBJLAY_SHAPE_BINARY_ONLY             2  #define VIDOBJLAY_SHAPE_BINARY_ONLY             2
90  #define VIDOBJLAY_SHAPE_GRAYSCALE               3  #define VIDOBJLAY_SHAPE_GRAYSCALE               3
91    
92  #define VO_START_CODE   0x8  
93  #define VOL_START_CODE  0x12  #define SPRITE_NONE             0
94  #define VOP_START_CODE  0x1b6  #define SPRITE_STATIC   1
95    #define SPRITE_GMC              2
96    
97    
98    
99  #define READ_MARKER()   BitstreamSkip(bs, 1)  #define READ_MARKER()   BitstreamSkip(bs, 1)
100  #define WRITE_MARKER()  BitstreamPutBit(bs, 1)  #define WRITE_MARKER()  BitstreamPutBit(bs, 1)
101    
102  // vop coding types  /* vop coding types  */
103  // intra, prediction, backward, sprite, not_coded  /* intra, prediction, backward, sprite, not_coded */
104  #define I_VOP   0  #define I_VOP   0
105  #define P_VOP   1  #define P_VOP   1
106  #define B_VOP   2  #define B_VOP   2
107  #define S_VOP   3  #define S_VOP   3
108  #define N_VOP   4  #define N_VOP   4
109    
110    /* resync-specific */
111  // header stuff  #define NUMBITS_VP_RESYNC_MARKER  17
112  int BitstreamReadHeaders(Bitstream * bs, DECODER * dec, uint32_t * rounding,  #define RESYNC_MARKER 1
113                                                   uint32_t * quant, uint32_t * fcode, uint32_t * intra_dc_threshold);  
114    
115    /*****************************************************************************
116     * Prototypes
117     ****************************************************************************/
118    
119    int read_video_packet_header(Bitstream *bs,
120                                                             DECODER * dec,
121                                                             const int addbits,
122                                                             int *quant,
123                                                             int *fcode_forward,
124                                                             int *fcode_backward,
125                                                             int *intra_dc_threshold);
126    
127    /* header stuff */
128    int BitstreamReadHeaders(Bitstream * bs,
129                                                     DECODER * dec,
130                                                     uint32_t * rounding,
131                                                     uint32_t * quant,
132                                                     uint32_t * fcode_forward,
133                                                     uint32_t * fcode_backward,
134                                                     uint32_t * intra_dc_threshold,
135                                                     WARPPOINTS * gmc_warp);
136    
137    
138  void BitstreamWriteVolHeader(Bitstream * const bs,  void BitstreamWriteVolHeader(Bitstream * const bs,
139                                                  const MBParam * pParam,                                                  const MBParam * pParam,
140                                                  const FRAMEINFO * frame);                                                           const FRAMEINFO * const frame,
141                                                             const int num_slices);
142    
143  void BitstreamWriteVopHeader(Bitstream * const bs,  void BitstreamWriteVopHeader(Bitstream * const bs,
144                                                  const MBParam * pParam,                                                  const MBParam * pParam,
145                                                  const FRAMEINFO * frame);                                                           const FRAMEINFO * const frame,
146                                                             int vop_coded,
147                                                             unsigned int quant);
148    
149    void BitstreamWriteUserData(Bitstream * const bs,
150                                                            const char *data,
151                                                            const unsigned int length);
152    
153    void
154    BitstreamWriteEndOfSequence(Bitstream * const bs);
155    
156    void
157    BitstreamWriteGroupOfVopHeader(Bitstream * const bs,
158                                   const MBParam * pParam,
159                                   uint32_t is_closed_gov);
160    
161    void write_video_packet_header(Bitstream * const bs,
162                                   const MBParam * pParam,
163                                   const FRAMEINFO * const frame,
164                                   int mbnum);
165    
166    /*****************************************************************************
167     * Bitstream
168     ****************************************************************************/
169    
170    /* Input buffer should be readable as full chunks of 8bytes, including
171    the end of the buffer. Padding might be appropriate. If only chunks
172    of 4bytes are applicable, define XVID_SAFE_BS_TAIL. Note that this will
173    slow decoding, so consider this as a last-resort solution */
174    #ifndef XVID_HAVE_PADDED_BS_BUFFER
175    #define XVID_SAFE_BS_TAIL
176    #endif
177    
178  /* initialise bitstream structure */  /* initialise bitstream structure */
179    
180  static void __inline BitstreamInit(Bitstream * const bs,  static void __inline
181    BitstreamInit(Bitstream * const bs,
182                                                                     void * const bitstream,                                                                     void * const bitstream,
183                                                                     uint32_t length)                                                                     uint32_t length)
184  {  {
185          uint32_t tmp;          uint32_t tmp;
186            size_t bitpos;
187            ptr_t adjbitstream = (ptr_t)bitstream;
188    
189          bs->start = bs->tail = (uint32_t*)bitstream;          /*
190             * Start the stream on a uint32_t boundary, by rounding down to the
191             * previous uint32_t and skipping the intervening bytes.
192             */
193            bitpos = ((sizeof(uint32_t)-1) & (size_t)bitstream);
194            adjbitstream = adjbitstream - bitpos;
195            bs->start = bs->tail = (uint32_t *) adjbitstream;
196    
197          tmp = *(uint32_t *)bitstream;          tmp = *bs->start;
198  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
199          BSWAP(tmp);          BSWAP(tmp);
200  #endif  #endif
201          bs->bufa = tmp;          bs->bufa = tmp;
202    
203          tmp = *((uint32_t *)bitstream + 1);          tmp = *(bs->start + 1);
204  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
205          BSWAP(tmp);          BSWAP(tmp);
206  #endif  #endif
207          bs->bufb = tmp;          bs->bufb = tmp;
208    
209            bs->pos = bs->initpos = (uint32_t) bitpos*8;
210            /* preserve the intervening bytes */
211            if (bs->initpos > 0)
212                    bs->buf = bs->bufa & (0xffffffff << (32 - bs->initpos));
213            else
214          bs->buf = 0;          bs->buf = 0;
         bs->pos = 0;  
215          bs->length = length;          bs->length = length;
216  }  }
217    
218    
219  /* reset bitstream state */  /* reset bitstream state */
220    
221  static void __inline BitstreamReset(Bitstream * const bs)  static void __inline
222    BitstreamReset(Bitstream * const bs)
223  {  {
224          uint32_t tmp;          uint32_t tmp;
225    
# Line 172  Line 237 
237  #endif  #endif
238          bs->bufb = tmp;          bs->bufb = tmp;
239    
240            /* preserve the intervening bytes */
241            if (bs->initpos > 0)
242                    bs->buf = bs->bufa & (0xffffffff << (32 - bs->initpos));
243            else
244          bs->buf = 0;          bs->buf = 0;
245      bs->pos = 0;          bs->pos = bs->initpos;
246  }  }
247    
248    
249  /* reads n bits from bitstream without changing the stream pos */  /* reads n bits from bitstream without changing the stream pos */
250    
251  static uint32_t __inline BitstreamShowBits(Bitstream * const bs,  static uint32_t __inline
252    BitstreamShowBits(Bitstream * const bs,
253                                                                                     const uint32_t bits)                                                                                     const uint32_t bits)
254  {  {
255          int nbit = (bits + bs->pos) - 32;          int nbit = (bits + bs->pos) - 32;
256          if (nbit > 0)  
257          {          if (nbit > 0) {
258                  return ((bs->bufa & (0xffffffff >> bs->pos)) << nbit) |                  return ((bs->bufa & (0xffffffff >> bs->pos)) << nbit) | (bs->
259                                  (bs->bufb >> (32 - nbit));                                                                                                                                   bufb >> (32 -
260          }                                                                                                                                                    nbit));
261          else          } else {
         {  
262                  return (bs->bufa & (0xffffffff >> bs->pos)) >> (32 - bs->pos - bits);                  return (bs->bufa & (0xffffffff >> bs->pos)) >> (32 - bs->pos - bits);
263          }          }
264  }  }
# Line 197  Line 266 
266    
267  /* skip n bits forward in bitstream */  /* skip n bits forward in bitstream */
268    
269  static __inline void BitstreamSkip(Bitstream * const bs, const uint32_t bits)  static __inline void
270    BitstreamSkip(Bitstream * const bs,
271                              const uint32_t bits)
272  {  {
273          bs->pos += bits;          bs->pos += bits;
274    
275          if (bs->pos >= 32)          if (bs->pos >= 32) {
         {  
276                  uint32_t tmp;                  uint32_t tmp;
277    
278                  bs->bufa = bs->bufb;                  bs->bufa = bs->bufb;
279    #if defined(XVID_SAFE_BS_TAIL)
280                    if (bs->tail<(bs->start+((bs->length+3)>>2)))
281    #endif
282                    {
283                  tmp = *((uint32_t *)bs->tail + 2);                  tmp = *((uint32_t *)bs->tail + 2);
284  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
285                  BSWAP(tmp);                  BSWAP(tmp);
286  #endif  #endif
287                  bs->bufb = tmp;                  bs->bufb = tmp;
288                  bs->tail++;                  bs->tail++;
289                    }
290    #if defined(XVID_SAFE_BS_TAIL)
291                    else {
292                            bs->bufb = 0;
293                    }
294    #endif
295                  bs->pos -= 32;                  bs->pos -= 32;
296          }          }
297  }  }
298    
299    
300    /* number of bits to next byte alignment */
301    static __inline uint32_t
302    BitstreamNumBitsToByteAlign(Bitstream *bs)
303    {
304            uint32_t n = (32 - bs->pos) % 8;
305            return n == 0 ? 8 : n;
306    }
307    
308    
309    /* show nbits from next byte alignment */
310    static __inline uint32_t
311    BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)
312    {
313            int bspos = bs->pos + BitstreamNumBitsToByteAlign(bs);
314            int nbit = (bits + bspos) - 32;
315    
316            if (bspos >= 32) {
317                    return bs->bufb >> (32 - nbit);
318            } else  if (nbit > 0) {
319                    return ((bs->bufa & (0xffffffff >> bspos)) << nbit) | (bs->
320                                                                                                                                     bufb >> (32 -
321                                                                                                                                                      nbit));
322            } else {
323                    return (bs->bufa & (0xffffffff >> bspos)) >> (32 - bspos - bits);
324            }
325    
326    }
327    
328    
329    
330  /* move forward to the next byte boundary */  /* move forward to the next byte boundary */
331    
332  static __inline void BitstreamByteAlign(Bitstream * const bs)  static __inline void
333    BitstreamByteAlign(Bitstream * const bs)
334  {  {
335          uint32_t remainder = bs->pos % 8;          uint32_t remainder = bs->pos % 8;
336          if (remainder)  
337          {          if (remainder) {
338                  BitstreamSkip(bs, 8 - remainder);                  BitstreamSkip(bs, 8 - remainder);
339          }          }
340  }  }
# Line 231  Line 342 
342    
343  /* bitstream length (unit bits) */  /* bitstream length (unit bits) */
344    
345  static uint32_t __inline BitstreamPos(const Bitstream * const bs)  static uint32_t __inline
346    BitstreamPos(const Bitstream * const bs)
347  {  {
348      return 8 * ((uint32_t)bs->tail - (uint32_t)bs->start) + bs->pos;          return((uint32_t)(8*((ptr_t)bs->tail - (ptr_t)bs->start) + bs->pos - bs->initpos));
349  }  }
350    
351    
352  /*      flush the bitstream & return length (unit bytes)  /*
353          NOTE: assumes no futher bitstream functions will be called.   * flush the bitstream & return length (unit bytes)
354     * NOTE: assumes no futher bitstream functions will be called.
355   */   */
356    
357  static uint32_t __inline BitstreamLength(Bitstream * const bs)  static uint32_t __inline
358    BitstreamLength(Bitstream * const bs)
359  {  {
360          uint32_t len = (uint32_t) bs->tail - (uint32_t) bs->start;          uint32_t len = (uint32_t)((ptr_t)bs->tail - (ptr_t)bs->start);
361    
362      if (bs->pos)          if (bs->pos) {
     {  
363                  uint32_t b = bs->buf;                  uint32_t b = bs->buf;
364    
365  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
366                  BSWAP(b);                  BSWAP(b);
367  #endif  #endif
# Line 256  Line 370 
370                  len += (bs->pos + 7) / 8;                  len += (bs->pos + 7) / 8;
371      }      }
372    
373            /* initpos is always on a byte boundary */
374            if (bs->initpos)
375                    len -= bs->initpos/8;
376    
377          return len;          return len;
378  }  }
379    
380    
381  /* move bitstream position forward by n bits and write out buffer if needed */  /* move bitstream position forward by n bits and write out buffer if needed */
382    
383  static void __inline BitstreamForward(Bitstream * const bs, const uint32_t bits)  static void __inline
384    BitstreamForward(Bitstream * const bs,
385                                     const uint32_t bits)
386  {  {
387      bs->pos += bits;      bs->pos += bits;
388    
389      if (bs->pos >= 32)          if (bs->pos >= 32) {
     {  
390                  uint32_t b = bs->buf;                  uint32_t b = bs->buf;
391    
392  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
393                  BSWAP(b);                  BSWAP(b);
394  #endif  #endif
# Line 278  Line 398 
398      }      }
399  }  }
400    
   
 /* pad bitstream to the next byte boundary */  
   
 static void __inline BitstreamPad(Bitstream * const bs)  
 {  
         uint32_t remainder = bs->pos % 8;  
   
     if (remainder)  
     {  
                 BitstreamForward(bs, 8 - remainder);  
     }  
 }  
   
   
401  /* read n bits from bitstream */  /* read n bits from bitstream */
402    
403  static uint32_t __inline BitstreamGetBits(Bitstream * const bs,  static uint32_t __inline
404    BitstreamGetBits(Bitstream * const bs,
405                                                                                    const uint32_t n)                                                                                    const uint32_t n)
406  {  {
407          uint32_t ret = BitstreamShowBits(bs, n);          uint32_t ret = BitstreamShowBits(bs, n);
408    
409          BitstreamSkip(bs, n);          BitstreamSkip(bs, n);
410          return ret;          return ret;
411  }  }
# Line 305  Line 413 
413    
414  /* read single bit from bitstream */  /* read single bit from bitstream */
415    
416  static uint32_t __inline BitstreamGetBit(Bitstream * const bs)  static uint32_t __inline
417    BitstreamGetBit(Bitstream * const bs)
418  {  {
419          return BitstreamGetBits(bs, 1);          return BitstreamGetBits(bs, 1);
420  }  }
# Line 313  Line 422 
422    
423  /* write single bit to bitstream */  /* write single bit to bitstream */
424    
425  static void __inline BitstreamPutBit(Bitstream * const bs,  static void __inline
426    BitstreamPutBit(Bitstream * const bs,
427                                                                          const uint32_t bit)                                                                          const uint32_t bit)
428  {  {
429      if (bit)      if (bit)
# Line 325  Line 435 
435    
436  /* write n bits to bitstream */  /* write n bits to bitstream */
437    
438  static void __inline BitstreamPutBits(Bitstream * const bs,  static void __inline
439    BitstreamPutBits(Bitstream * const bs,
440                                                                          const uint32_t value,                                                                          const uint32_t value,
441                                                                          const uint32_t size)                                                                          const uint32_t size)
442  {  {
# Line 349  Line 460 
460          }          }
461  }  }
462    
463    static const int stuffing_codes[8] =
464    {
465                    /* nbits     stuffing code */
466            0,              /* 1          0 */
467            1,              /* 2          01 */
468            3,              /* 3          011 */
469            7,              /* 4          0111 */
470            0xf,    /* 5          01111 */
471            0x1f,   /* 6          011111 */
472            0x3f,   /* 7          0111111 */
473            0x7f,   /* 8          01111111 */
474    };
475    
476    /* pad bitstream to the next byte boundary */
477    
478    static void __inline
479    BitstreamPad(Bitstream * const bs)
480    {
481            int bits = 8 - (bs->pos % 8);
482            if (bits < 8)
483                    BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
484    }
485    
486    
487    /*
488     * pad bitstream to the next byte boundary
489     * alway pad: even if currently at the byte boundary
490     */
491    
492    static void __inline
493    BitstreamPadAlways(Bitstream * const bs)
494    {
495            int bits = 8 - (bs->pos % 8);
496            BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
497    }
498    
499  #endif /* _BITSTREAM_H_ */  #endif /* _BITSTREAM_H_ */
Legend:
Removed from v.136  
changed lines
  Added in v.2177
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4