[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.16.2.2, Mon Jul 28 12:39:32 2003 UTC revision 1.26, Tue Dec 28 19:19:43 2010 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 57  Line 26 
26  #ifndef _BITSTREAM_H_  #ifndef _BITSTREAM_H_
27  #define _BITSTREAM_H_  #define _BITSTREAM_H_
28    
 #include <stdio.h>  
   
29  #include "../portab.h"  #include "../portab.h"
30  #include "../decoder.h"  #include "../decoder.h"
31  #include "../encoder.h"  #include "../encoder.h"
# Line 78  Line 45 
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
# Line 91  Line 58 
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_TYPE_ANIM_MESH                      7 */
66    /*#define VIDOBJLAY_TYPE_SIMPLE_FACE            8 */
67    /*#define VIDOBJLAY_TYPE_STILL_SCALABLE         9 */
68    #define VIDOBJLAY_TYPE_ART_SIMPLE               10
69    /*#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 */  /*#define VIDOBJLAY_AR_SQUARE           1 */
# Line 108  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)
# Line 132  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,
# Line 143  Line 131 
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                                                             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);                                                           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   * Inlined functions   * 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    
178  static void __inline  static void __inline
# Line 190  Line 204 
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 = bs->initpos = bitpos*8;  
213          bs->length = length;          bs->length = length;
214  }  }
215    
# Line 217  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 = bs->initpos;          bs->pos = bs->initpos;
244  }  }
# Line 242  Line 264 
264    
265  /* skip n bits forward in bitstream */  /* skip n bits forward in bitstream */
266    
267  static void __inline  static __inline void
268  BitstreamSkip(Bitstream * const bs,  BitstreamSkip(Bitstream * const bs,
269                            const uint32_t bits)                            const uint32_t bits)
270  {  {
# Line 252  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 uint32_t __inline  static __inline uint32_t
300  BitstreamNumBitsToByteAlign(Bitstream *bs)  BitstreamNumBitsToByteAlign(Bitstream *bs)
301  {  {
302          uint32_t n = (32 - bs->pos) % 8;          uint32_t n = (32 - bs->pos) % 8;
# Line 273  Line 305 
305    
306    
307  /* show nbits from next byte alignment */  /* show nbits from next byte alignment */
308  static uint32_t __inline  static __inline uint32_t
309  BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)  BitstreamShowBitsFromByteAlign(Bitstream *bs, int bits)
310  {  {
311          int bspos = bs->pos + BitstreamNumBitsToByteAlign(bs);          int bspos = bs->pos + BitstreamNumBitsToByteAlign(bs);
# Line 295  Line 327 
327    
328  /* move forward to the next byte boundary */  /* move forward to the next byte boundary */
329    
330  static void __inline  static __inline void
331  BitstreamByteAlign(Bitstream * const bs)  BitstreamByteAlign(Bitstream * const bs)
332  {  {
333          uint32_t remainder = bs->pos % 8;          uint32_t remainder = bs->pos % 8;
# Line 315  Line 347 
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
# Line 448  Line 481 
481                  BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);                  BitstreamPutBits(bs, stuffing_codes[bits - 1], bits);
482  }  }
483    
484    
485  /*  /*
486   * pad bitstream to the next byte boundary   * pad bitstream to the next byte boundary
487   * alway pad: even if currently at the byte boundary   * alway pad: even if currently at the byte boundary

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

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