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

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

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

revision 1.14, Sun Nov 17 00:57:57 2002 UTC revision 1.22.2.2, Wed Nov 1 09:26:52 2006 UTC
# Line 3  Line 3 
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - Bitstream reader/writer inlined functions and constants-   *  - Bitstream reader/writer inlined functions and constants-
5   *   *
6   *  Copyright (C) 2001-2002 - Peter Ross <pross@xvid.org>   *  Copyright (C) 2001-2003 Peter Ross <pross@xvid.org>
7   *   *
8   *  This file is part of XviD, a free MPEG-4 video encoder/decoder   *  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
  *  XviD is free software; you can redistribute it and/or modify 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   *  the Free Software Foundation; either version 2 of the License, or
11   *  (at your option) any later version.   *  (at your option) any later version.
12   *   *
# Line 21  Line 19 
19   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
  *  Under section 8 of the GNU General Public License, the copyright  
  *  holders of XVID explicitly forbid distribution in the following  
  *  countries:  
  *  
  *    - Japan  
  *    - United States of America  
  *  
  *  Linking XviD statically or dynamically with other modules is making a  
  *  combined work based on XviD.  Thus, the terms and conditions of the  
  *  GNU General Public License cover the whole combination.  
  *  
  *  As a special exception, the copyright holders of XviD give you  
  *  permission to link XviD with independent modules that communicate with  
  *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the  
  *  license terms of these independent modules, and to copy and distribute  
  *  the resulting combined work under terms of your choice, provided that  
  *  every copy of the combined work is accompanied by a complete copy of  
  *  the source code of XviD (the version of XviD used to produce the  
  *  combined work), being distributed under the terms of the GNU General  
  *  Public License plus this exception.  An independent module is a module  
  *  which is not derived from or based on XviD.  
  *  
  *  Note that people who make modified versions of XviD are not obligated  
  *  to grant this special exception for their modified versions; it is  
  *  their choice whether to do so.  The GNU General Public License gives  
  *  permission to release a modified version without this exception; this  
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
  *  
22   * $Id$   * $Id$
23   *   *
24   ****************************************************************************/   ****************************************************************************/
# Line 66  Line 35 
35   * Constants   * Constants
36   ****************************************************************************/   ****************************************************************************/
37    
38  // comment any #defs we dont use  /* 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 74  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 106  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  /* resync-specific */
111  #define NUMBITS_VP_RESYNC_MARKER  17  #define NUMBITS_VP_RESYNC_MARKER  17
112  #define RESYNC_MARKER 1  #define RESYNC_MARKER 1
113    
# Line 130  Line 116 
116   * Prototypes   * Prototypes
117   ****************************************************************************/   ****************************************************************************/
118    
119  int  int read_video_packet_header(Bitstream *bs,
120  read_video_packet_header(Bitstream *bs, const int addbits, int * quant);                                                           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  /* header stuff */
128  int BitstreamReadHeaders(Bitstream * bs,  int BitstreamReadHeaders(Bitstream * bs,
129                                                   DECODER * dec,                                                   DECODER * dec,
130                                                   uint32_t * rounding,                                                   uint32_t * rounding,
131                                                   uint32_t * quant,                                                   uint32_t * quant,
132                                                   uint32_t * fcode_forward,                                                   uint32_t * fcode_forward,
133                                                   uint32_t * fcode_backward,                                                   uint32_t * fcode_backward,
134                                                   uint32_t * intra_dc_threshold);                                                   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    
142  void BitstreamWriteVopHeader(Bitstream * const bs,  void BitstreamWriteVopHeader(Bitstream * const bs,
143                                                           const MBParam * pParam,                                                           const MBParam * pParam,
144                                                           const FRAMEINFO * frame,                                                           const FRAMEINFO * const frame,
145                                                           int vop_coded);                                                           int vop_coded,
146                                                             unsigned int quant);
147    
148    void BitstreamWriteUserData(Bitstream * const bs,
149                                                            const char *data,
150                                                            const unsigned int length);
151    
152    void
153    BitstreamWriteEndOfSequence(Bitstream * const bs);
154    
155    void
156    BitstreamWriteGroupOfVopHeader(Bitstream * const bs,
157                                   const MBParam * pParam,
158                                   uint32_t is_closed_gov);
159    
160    void write_video_packet_header(Bitstream * const bs,
161                                   const MBParam * pParam,
162                                   const FRAMEINFO * const frame,
163                                   int mbnum);
164    
165  /*****************************************************************************  /*****************************************************************************
166   * Inlined functions   * Bitstream
167   ****************************************************************************/   ****************************************************************************/
168    
169    /* Input buffer should be readable as full chunks of 8bytes, including
170    the end of the buffer. Padding might be appropriate. If only chunks
171    of 4bytes are applicable, define XVID_SAFE_BS_TAIL. Note that this will
172    slow decoding, so consider this as a last-resort solution */
173    /* #define XVID_SAFE_BS_TAIL */
174    
175  /* initialise bitstream structure */  /* initialise bitstream structure */
176    
177  static void __inline  static void __inline
# Line 165  Line 180 
180                            uint32_t length)                            uint32_t length)
181  {  {
182          uint32_t tmp;          uint32_t tmp;
183            size_t bitpos;
184            ptr_t adjbitstream = (ptr_t)bitstream;
185    
186          bs->start = bs->tail = (uint32_t *) bitstream;          /*
187             * Start the stream on a uint32_t boundary, by rounding down to the
188             * previous uint32_t and skipping the intervening bytes.
189             */
190            bitpos = ((sizeof(uint32_t)-1) & (size_t)bitstream);
191            adjbitstream = adjbitstream - bitpos;
192            bs->start = bs->tail = (uint32_t *) adjbitstream;
193    
194          tmp = *(uint32_t *) bitstream;          tmp = *bs->start;
195  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
196          BSWAP(tmp);          BSWAP(tmp);
197  #endif  #endif
198          bs->bufa = tmp;          bs->bufa = tmp;
199    
200          tmp = *((uint32_t *) bitstream + 1);          tmp = *(bs->start + 1);
201  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
202          BSWAP(tmp);          BSWAP(tmp);
203  #endif  #endif
204          bs->bufb = tmp;          bs->bufb = tmp;
205    
206            bs->pos = bs->initpos = bitpos*8;
207            /* preserve the intervening bytes */
208            if (bs->initpos > 0)
209                    bs->buf = bs->bufa & (0xffffffff << (32 - bs->initpos));
210            else
211          bs->buf = 0;          bs->buf = 0;
         bs->pos = 0;  
212          bs->length = length;          bs->length = length;
213  }  }
214    
# Line 207  Line 234 
234  #endif  #endif
235          bs->bufb = tmp;          bs->bufb = tmp;
236    
237            /* preserve the intervening bytes */
238            if (bs->initpos > 0)
239                    bs->buf = bs->bufa & (0xffffffff << (32 - bs->initpos));
240            else
241          bs->buf = 0;          bs->buf = 0;
242          bs->pos = 0;          bs->pos = bs->initpos;
243  }  }
244    
245    
# Line 232  Line 263 
263    
264  /* skip n bits forward in bitstream */  /* skip n bits forward in bitstream */
265    
266  static void __inline  static __inline void
267  BitstreamSkip(Bitstream * const bs,  BitstreamSkip(Bitstream * const bs,
268                            const uint32_t bits)                            const uint32_t bits)
269  {  {
# Line 242  Line 273 
273                  uint32_t tmp;                  uint32_t tmp;
274    
275                  bs->bufa = bs->bufb;                  bs->bufa = bs->bufb;
276    #if defined(XVID_SAFE_BS_TAIL)
277                    if (bs->tail<(bs->start+((bs->length+3)>>2)))
278    #endif
279                    {
280                  tmp = *((uint32_t *) bs->tail + 2);                  tmp = *((uint32_t *) bs->tail + 2);
281  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
282                  BSWAP(tmp);                  BSWAP(tmp);
283  #endif  #endif
284                  bs->bufb = tmp;                  bs->bufb = tmp;
285                  bs->tail++;                  bs->tail++;
286                    }
287    #if defined(XVID_SAFE_BS_TAIL)
288                    else {
289                            bs->bufb = 0;
290                    }
291    #endif
292                  bs->pos -= 32;                  bs->pos -= 32;
293          }          }
294  }  }
295    
296    
297  // number of bits to next byte alignment  /* number of bits to next byte alignment */
298  static uint32_t __inline  static __inline uint32_t
299  BitstreamNumBitsToByteAlign(Bitstream *bs)  BitstreamNumBitsToByteAlign(Bitstream *bs)
300  {  {
301          uint32_t n = (32 - bs->pos) % 8;          uint32_t n = (32 - bs->pos) % 8;
# Line 262  Line 303 
303  }  }
304    
305    
306  // show nbits from next byte alignment  /* show nbits from next byte alignment */
307  static uint32_t __inline  static __inline uint32_t
308  BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)  BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)
309  {  {
310          int bspos = bs->pos + BitstreamNumBitsToByteAlign(bs);          int bspos = bs->pos + BitstreamNumBitsToByteAlign(bs);
# Line 285  Line 326 
326    
327  /* move forward to the next byte boundary */  /* move forward to the next byte boundary */
328    
329  static void __inline  static __inline void
330  BitstreamByteAlign(Bitstream * const bs)  BitstreamByteAlign(Bitstream * const bs)
331  {  {
332          uint32_t remainder = bs->pos % 8;          uint32_t remainder = bs->pos % 8;
# Line 301  Line 342 
342  static uint32_t __inline  static uint32_t __inline
343  BitstreamPos(const Bitstream * const bs)  BitstreamPos(const Bitstream * const bs)
344  {  {
345          return 8 * ((ptr_t)bs->tail - (ptr_t)bs->start) + bs->pos;          return((uint32_t)(8*((ptr_t)bs->tail - (ptr_t)bs->start) + bs->pos - bs->initpos));
346  }  }
347    
348    
349  /*      flush the bitstream & return length (unit bytes)  /*
350          NOTE: assumes no futher bitstream functions will be called.   * flush the bitstream & return length (unit bytes)
351     * NOTE: assumes no futher bitstream functions will be called.
352   */   */
353    
354  static uint32_t __inline  static uint32_t __inline
355  BitstreamLength(Bitstream * const bs)  BitstreamLength(Bitstream * const bs)
356  {  {
357          uint32_t len = (ptr_t) bs->tail - (ptr_t) bs->start;          uint32_t len = (uint32_t)((ptr_t)bs->tail - (ptr_t)bs->start);
358    
359          if (bs->pos) {          if (bs->pos) {
360                  uint32_t b = bs->buf;                  uint32_t b = bs->buf;
# Line 325  Line 367 
367                  len += (bs->pos + 7) / 8;                  len += (bs->pos + 7) / 8;
368          }          }
369    
370            /* initpos is always on a byte boundary */
371            if (bs->initpos)
372                    len -= bs->initpos/8;
373    
374          return len;          return len;
375  }  }
376    
# Line 349  Line 395 
395          }          }
396  }  }
397    
   
 /* 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);  
         }  
 }  
   
   
398  /* read n bits from bitstream */  /* read n bits from bitstream */
399    
400  static uint32_t __inline  static uint32_t __inline
# Line 425  Line 457 
457          }          }
458  }  }
459    
460    static const int stuffing_codes[8] =
461    {
462                    /* nbits     stuffing code */
463            0,              /* 1          0 */
464            1,              /* 2          01 */
465            3,              /* 3          011 */
466            7,              /* 4          0111 */
467            0xf,    /* 5          01111 */
468            0x1f,   /* 6          011111 */
469            0x3f,   /* 7          0111111 */
470            0x7f,   /* 8          01111111 */
471    };
472    
473    /* pad bitstream to the next byte boundary */
474    
475    static void __inline
476    BitstreamPad(Bitstream * const bs)
477    {
478            int bits = 8 - (bs->pos % 8);
479            if (bits < 8)
480                    BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
481    }
482    
483    
484    /*
485     * pad bitstream to the next byte boundary
486     * alway pad: even if currently at the byte boundary
487     */
488    
489    static void __inline
490    BitstreamPadAlways(Bitstream * const bs)
491    {
492            int bits = 8 - (bs->pos % 8);
493            BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
494    }
495    
496  #endif /* _BITSTREAM_H_ */  #endif /* _BITSTREAM_H_ */

Legend:
Removed from v.1.14  
changed lines
  Added in v.1.22.2.2

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4