[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.10.2.5, Sat Jan 11 14:59:24 2003 UTC revision 1.26, Tue Dec 28 19:19:43 2010 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:                                                         *  
   *                                                                            *  
   *  28.06.2002 addded BitstreamNumBitsToByteAlign()                           *  
   *                    BitstreamShowBitsFromByteAlign()                        *  
   *  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 57  Line 30 
30  #include "../decoder.h"  #include "../decoder.h"
31  #include "../encoder.h"  #include "../encoder.h"
32    
 // comment any #defs we dont use  
33    
34  /* start codes */  /*****************************************************************************
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 67  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 VOP_START_CODE                  0x000001b6  #define VOP_START_CODE                  0x000001b6
49  //#define STUFFING_START_CODE   0x000001c3  /*#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  /*#define VIDOBJLAY_TYPE_NBIT                           5 */
64  //#define VIDOBJLAY_TYPE_ANIM_TEXT                      6  /*#define VIDOBJLAY_TYPE_ANIM_TEXT                      6 */
65  //#define VIDOBJLAY_TYPE_ANIM_MESH                      7  /*#define VIDOBJLAY_TYPE_ANIM_MESH                      7 */
66  //#define VIDOBJLAY_TYPE_SIMPLE_FACE            8  /*#define VIDOBJLAY_TYPE_SIMPLE_FACE            8 */
67  //#define VIDOBJLAY_TYPE_STILL_SCALABLE         9  /*#define VIDOBJLAY_TYPE_STILL_SCALABLE         9 */
68  #define VIDOBJLAY_TYPE_ART_SIMPLE               10  #define VIDOBJLAY_TYPE_ART_SIMPLE               10
69  //#define VIDOBJLAY_TYPE_CORE_SCALABLE          11  /*#define VIDOBJLAY_TYPE_CORE_SCALABLE          11 */
70  #define VIDOBJLAY_TYPE_ACE                              12  /*#define VIDOBJLAY_TYPE_ACE                            12 */
71  //#define VIDOBJLAY_TYPE_SIMPLE_FBA                     13  /*#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  /*#define VIDOBJLAY_AR_SQUARE           1 */
80  //#define VIDOBJLAY_AR_625TYPE_43       2  /*#define VIDOBJLAY_AR_625TYPE_43       2 */
81  //#define VIDOBJLAY_AR_525TYPE_43       3  /*#define VIDOBJLAY_AR_525TYPE_43       3 */
82  //#define VIDOBJLAY_AR_625TYPE_169      8  /*#define VIDOBJLAY_AR_625TYPE_169      8 */
83  //#define VIDOBJLAY_AR_525TYPE_169      9  /*#define VIDOBJLAY_AR_525TYPE_169      9 */
84  #define VIDOBJLAY_AR_EXTPAR                             15  #define VIDOBJLAY_AR_EXTPAR                             15
85    
86    
# Line 118  Line 99 
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    
114    
115    /*****************************************************************************
116     * Prototypes
117     ****************************************************************************/
118    
119  int read_video_packet_header(Bitstream *bs,  int read_video_packet_header(Bitstream *bs,
120                                                  DECODER * dec,                                                  DECODER * dec,
121                                                  const int addbits,                                                  const int addbits,
# Line 139  Line 124 
124                                                  int  * fcode_backward,                                                  int  * fcode_backward,
125                                                  int * intra_dc_threshold);                                                  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,
                                                  uint32_t * reduced_resolution,  
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,
# Line 154  Line 137 
137    
138  void BitstreamWriteVolHeader(Bitstream * const bs,  void BitstreamWriteVolHeader(Bitstream * const bs,
139                                                           const MBParam * pParam,                                                           const MBParam * pParam,
140                                                           const FRAMEINFO * const 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 * const frame,                                                           const FRAMEINFO * const frame,
146                                                           int vop_coded);                                                           int vop_coded,
147                                                             unsigned int quant);
148    
149  void BitstreamWriteUserData(Bitstream * const bs,  void BitstreamWriteUserData(Bitstream * const bs,
150                                                          uint8_t * data,                                                          const char *data,
151                                                          const int length);                                                          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    /* #define XVID_SAFE_BS_TAIL */
175    
176  /* initialise bitstream structure */  /* initialise bitstream structure */
177    
# Line 173  Line 181 
181                            uint32_t length)                            uint32_t length)
182  {  {
183          uint32_t tmp;          uint32_t tmp;
184            size_t bitpos;
185            ptr_t adjbitstream = (ptr_t)bitstream;
186    
187          bs->start = bs->tail = (uint32_t *) bitstream;          /*
188             * Start the stream on a uint32_t boundary, by rounding down to the
189             * previous uint32_t and skipping the intervening bytes.
190             */
191            bitpos = ((sizeof(uint32_t)-1) & (size_t)bitstream);
192            adjbitstream = adjbitstream - bitpos;
193            bs->start = bs->tail = (uint32_t *) adjbitstream;
194    
195          tmp = *(uint32_t *) bitstream;          tmp = *bs->start;
196  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
197          BSWAP(tmp);          BSWAP(tmp);
198  #endif  #endif
199          bs->bufa = tmp;          bs->bufa = tmp;
200    
201          tmp = *((uint32_t *) bitstream + 1);          tmp = *(bs->start + 1);
202  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
203          BSWAP(tmp);          BSWAP(tmp);
204  #endif  #endif
205          bs->bufb = tmp;          bs->bufb = tmp;
206    
207            bs->pos = bs->initpos = (uint32_t) bitpos*8;
208            /* preserve the intervening bytes */
209            if (bs->initpos > 0)
210                    bs->buf = bs->bufa & (0xffffffff << (32 - bs->initpos));
211            else
212          bs->buf = 0;          bs->buf = 0;
         bs->pos = 0;  
213          bs->length = length;          bs->length = length;
214  }  }
215    
# Line 215  Line 235 
235  #endif  #endif
236          bs->bufb = tmp;          bs->bufb = tmp;
237    
238            /* preserve the intervening bytes */
239            if (bs->initpos > 0)
240                    bs->buf = bs->bufa & (0xffffffff << (32 - bs->initpos));
241            else
242          bs->buf = 0;          bs->buf = 0;
243          bs->pos = 0;          bs->pos = bs->initpos;
244  }  }
245    
246    
# Line 250  Line 274 
274                  uint32_t tmp;                  uint32_t tmp;
275    
276                  bs->bufa = bs->bufb;                  bs->bufa = bs->bufb;
277    #if defined(XVID_SAFE_BS_TAIL)
278                    if (bs->tail<(bs->start+((bs->length+3)>>2)))
279    #endif
280                    {
281                  tmp = *((uint32_t *) bs->tail + 2);                  tmp = *((uint32_t *) bs->tail + 2);
282  #ifndef ARCH_IS_BIG_ENDIAN  #ifndef ARCH_IS_BIG_ENDIAN
283                  BSWAP(tmp);                  BSWAP(tmp);
284  #endif  #endif
285                  bs->bufb = tmp;                  bs->bufb = tmp;
286                  bs->tail++;                  bs->tail++;
287                    }
288    #if defined(XVID_SAFE_BS_TAIL)
289                    else {
290                            bs->bufb = 0;
291                    }
292    #endif
293                  bs->pos -= 32;                  bs->pos -= 32;
294          }          }
295  }  }
296    
297    
298  // number of bits to next byte alignment  /* number of bits to next byte alignment */
299  static __inline uint32_t  static __inline uint32_t
300  BitstreamNumBitsToByteAlign(Bitstream *bs)  BitstreamNumBitsToByteAlign(Bitstream *bs)
301  {  {
# Line 270  Line 304 
304  }  }
305    
306    
307  // show nbits from next byte alignment  /* show nbits from next byte alignment */
308  static __inline uint32_t  static __inline uint32_t
309  BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)  BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)
310  {  {
# Line 309  Line 343 
343  static uint32_t __inline  static uint32_t __inline
344  BitstreamPos(const Bitstream * const bs)  BitstreamPos(const Bitstream * const bs)
345  {  {
346          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));
347  }  }
348    
349    
350  /*      flush the bitstream & return length (unit bytes)  /*
351          NOTE: assumes no futher bitstream functions will be called.   * flush the bitstream & return length (unit bytes)
352     * NOTE: assumes no futher bitstream functions will be called.
353   */   */
354    
355  static uint32_t __inline  static uint32_t __inline
356  BitstreamLength(Bitstream * const bs)  BitstreamLength(Bitstream * const bs)
357  {  {
358          uint32_t len = (ptr_t) bs->tail - (ptr_t) bs->start;          uint32_t len = (uint32_t)((ptr_t)bs->tail - (ptr_t)bs->start);
359    
360          if (bs->pos) {          if (bs->pos) {
361                  uint32_t b = bs->buf;                  uint32_t b = bs->buf;
# Line 333  Line 368 
368                  len += (bs->pos + 7) / 8;                  len += (bs->pos + 7) / 8;
369          }          }
370    
371            /* initpos is always on a byte boundary */
372            if (bs->initpos)
373                    len -= bs->initpos/8;
374    
375          return len;          return len;
376  }  }
377    
# Line 357  Line 396 
396          }          }
397  }  }
398    
   
399  /* read n bits from bitstream */  /* read n bits from bitstream */
400    
401  static uint32_t __inline  static uint32_t __inline
# Line 420  Line 458 
458          }          }
459  }  }
460    
   
461  static const int stuffing_codes[8] =  static const int stuffing_codes[8] =
462  {  {
463                  /* nbits     stuffing code */                  /* nbits     stuffing code */
# Line 441  Line 478 
478  {  {
479          int bits = 8 - (bs->pos % 8);          int bits = 8 - (bs->pos % 8);
480          if (bits < 8)          if (bits < 8)
         {  
481                  BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);                  BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
482          }          }
 }  
483    
484    
485  /* pad bitstream to the next byte boundary  /*
486     alway pad: even if currently at the byte boundary */   * pad bitstream to the next byte boundary
487     * alway pad: even if currently at the byte boundary
488     */
489    
490  static void __inline  static void __inline
491  BitstreamPadAlways(Bitstream * const bs)  BitstreamPadAlways(Bitstream * const bs)
# Line 457  Line 494 
494          BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);          BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
495  }  }
496    
   
497  #endif                                                  /* _BITSTREAM_H_ */  #endif                                                  /* _BITSTREAM_H_ */

Legend:
Removed from v.1.10.2.5  
changed lines
  Added in v.1.26

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