1 /*****************************************************************************
2 *
3 * XVID MPEG-4 VIDEO CODEC
4 * - Bitstream reader/writer inlined functions and constants-
5 *
6 * Copyright (C) 2001-2003 Peter Ross <pross@xvid.org>
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-1307 USA
21 *
22 * $Id: bitstream.h 2180 2019-11-12 14:48:35Z Isibaar $
23 *
24 ****************************************************************************/
25
26 #ifndef _BITSTREAM_H_
27 #define _BITSTREAM_H_
28
29 #include "../portab.h"
30 #include "../decoder.h"
31 #include "../encoder.h"
32
33
34 /*****************************************************************************
35 * Constants
36 ****************************************************************************/
37
38 /* comment any #defs we dont use */
39
40 #define VIDOBJ_START_CODE 0x00000100 /* ..0x0000011f */
41 #define VIDOBJLAY_START_CODE 0x00000120 /* ..0x0000012f */
42 #define VISOBJSEQ_START_CODE 0x000001b0
43 #define VISOBJSEQ_STOP_CODE 0x000001b1 /* ??? */
44 #define USERDATA_START_CODE 0x000001b2
45 #define GRPOFVOP_START_CODE 0x000001b3
46 /*#define VIDSESERR_ERROR_CODE 0x000001b4 */
47 #define VISOBJ_START_CODE 0x000001b5
48 #define VOP_START_CODE 0x000001b6
49 /*#define STUFFING_START_CODE 0x000001c3 */
50
51
52 #define VISOBJ_TYPE_VIDEO 1
53 /*#define VISOBJ_TYPE_STILLTEXTURE 2 */
54 /*#define VISOBJ_TYPE_MESH 3 */
55 /*#define VISOBJ_TYPE_FBA 4 */
56 /*#define VISOBJ_TYPE_3DMESH 5 */
57
58
59 #define VIDOBJLAY_TYPE_SIMPLE 1
60 /*#define VIDOBJLAY_TYPE_SIMPLE_SCALABLE 2 */
61 /*#define VIDOBJLAY_TYPE_CORE 3 */
62 /*#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 */
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
85
86
87 #define VIDOBJLAY_SHAPE_RECTANGULAR 0
88 #define VIDOBJLAY_SHAPE_BINARY 1
89 #define VIDOBJLAY_SHAPE_BINARY_ONLY 2
90 #define VIDOBJLAY_SHAPE_GRAYSCALE 3
91
92
93 #define SPRITE_NONE 0
94 #define SPRITE_STATIC 1
95 #define SPRITE_GMC 2
96
97
98
99 #define READ_MARKER() BitstreamSkip(bs, 1)
100 #define WRITE_MARKER() BitstreamPutBit(bs, 1)
101
102 /* vop coding types */
103 /* intra, prediction, backward, sprite, not_coded */
104 #define I_VOP 0
105 #define P_VOP 1
106 #define B_VOP 2
107 #define S_VOP 3
108 #define N_VOP 4
109
110 /* resync-specific */
111 #define NUMBITS_VP_RESYNC_MARKER 17
112 #define RESYNC_MARKER 1
113
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,
139 const MBParam * pParam,
140 const FRAMEINFO * const frame,
141 const int num_slices);
142
143 void BitstreamWriteVopHeader(Bitstream * const bs,
144 const MBParam * pParam,
145 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 */
179
180 static void __inline
BitstreamInit(Bitstream * const bs,void * const bitstream,uint32_t length)181 BitstreamInit(Bitstream * const bs,
182 void *const bitstream,
183 uint32_t length)
184 {
185 uint32_t tmp;
186 size_t bitpos;
187 ptr_t adjbitstream = (ptr_t)bitstream;
188
189 /*
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 = *bs->start;
198 #ifndef ARCH_IS_BIG_ENDIAN
199 BSWAP(tmp);
200 #endif
201 bs->bufa = tmp;
202
203 tmp = *(bs->start + 1);
204 #ifndef ARCH_IS_BIG_ENDIAN
205 BSWAP(tmp);
206 #endif
207 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;
215 bs->length = length;
216 }
217
218
219 /* reset bitstream state */
220
221 static void __inline
BitstreamReset(Bitstream * const bs)222 BitstreamReset(Bitstream * const bs)
223 {
224 uint32_t tmp;
225
226 bs->tail = bs->start;
227
228 tmp = *bs->start;
229 #ifndef ARCH_IS_BIG_ENDIAN
230 BSWAP(tmp);
231 #endif
232 bs->bufa = tmp;
233
234 tmp = *(bs->start + 1);
235 #ifndef ARCH_IS_BIG_ENDIAN
236 BSWAP(tmp);
237 #endif
238 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;
245 bs->pos = bs->initpos;
246 }
247
248
249 /* reads n bits from bitstream without changing the stream pos */
250
251 static uint32_t __inline
BitstreamShowBits(Bitstream * const bs,const uint32_t bits)252 BitstreamShowBits(Bitstream * const bs,
253 const uint32_t bits)
254 {
255 int nbit = (bits + bs->pos) - 32;
256
257 if (nbit > 0) {
258 return ((bs->bufa & (0xffffffff >> bs->pos)) << nbit) | (bs->
259 bufb >> (32 -
260 nbit));
261 } else {
262 return (bs->bufa & (0xffffffff >> bs->pos)) >> (32 - bs->pos - bits);
263 }
264 }
265
266
267 /* skip n bits forward in bitstream */
268
269 static __inline void
BitstreamSkip(Bitstream * const bs,const uint32_t bits)270 BitstreamSkip(Bitstream * const bs,
271 const uint32_t bits)
272 {
273 bs->pos += bits;
274
275 if (bs->pos >= 32) {
276 uint32_t tmp;
277
278 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);
284 #ifndef ARCH_IS_BIG_ENDIAN
285 BSWAP(tmp);
286 #endif
287 bs->bufb = tmp;
288 bs->tail++;
289 }
290 #if defined(XVID_SAFE_BS_TAIL)
291 else {
292 bs->bufb = 0;
293 }
294 #endif
295 bs->pos -= 32;
296 }
297 }
298
299
300 /* number of bits to next byte alignment */
301 static __inline uint32_t
BitstreamNumBitsToByteAlign(Bitstream * bs)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
BitstreamShowBitsFromByteAlign(Bitstream * bs,int bits)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 */
331
332 static __inline void
BitstreamByteAlign(Bitstream * const bs)333 BitstreamByteAlign(Bitstream * const bs)
334 {
335 uint32_t remainder = bs->pos % 8;
336
337 if (remainder) {
338 BitstreamSkip(bs, 8 - remainder);
339 }
340 }
341
342
343 /* bitstream length (unit bits) */
344
345 static uint32_t __inline
BitstreamPos(const Bitstream * const bs)346 BitstreamPos(const Bitstream * const bs)
347 {
348 return((uint32_t)(8*((ptr_t)bs->tail - (ptr_t)bs->start) + bs->pos - bs->initpos));
349 }
350
351
352 /*
353 * 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)358 BitstreamLength(Bitstream * const bs)
359 {
360 uint32_t len = (uint32_t)((ptr_t)bs->tail - (ptr_t)bs->start);
361
362 if (bs->pos) {
363 uint32_t b = bs->buf;
364
365 #ifndef ARCH_IS_BIG_ENDIAN
366 BSWAP(b);
367 #endif
368 *bs->tail = b;
369
370 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;
378 }
379
380
381 /* 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)384 BitstreamForward(Bitstream * const bs,
385 const uint32_t bits)
386 {
387 bs->pos += bits;
388
389 if (bs->pos >= 32) {
390 uint32_t b = bs->buf;
391
392 #ifndef ARCH_IS_BIG_ENDIAN
393 BSWAP(b);
394 #endif
395 *bs->tail++ = b;
396 bs->buf = 0;
397 bs->pos -= 32;
398 }
399 }
400
401 /* read n bits from bitstream */
402
403 static uint32_t __inline
BitstreamGetBits(Bitstream * const bs,const uint32_t n)404 BitstreamGetBits(Bitstream * const bs,
405 const uint32_t n)
406 {
407 uint32_t ret = BitstreamShowBits(bs, n);
408
409 BitstreamSkip(bs, n);
410 return ret;
411 }
412
413
414 /* read single bit from bitstream */
415
416 static uint32_t __inline
BitstreamGetBit(Bitstream * const bs)417 BitstreamGetBit(Bitstream * const bs)
418 {
419 return BitstreamGetBits(bs, 1);
420 }
421
422
423 /* write single bit to bitstream */
424
425 static void __inline
BitstreamPutBit(Bitstream * const bs,const uint32_t bit)426 BitstreamPutBit(Bitstream * const bs,
427 const uint32_t bit)
428 {
429 if (bit)
430 bs->buf |= (0x80000000 >> bs->pos);
431
432 BitstreamForward(bs, 1);
433 }
434
435
436 /* write n bits to bitstream */
437
438 static void __inline
BitstreamPutBits(Bitstream * const bs,const uint32_t value,const uint32_t size)439 BitstreamPutBits(Bitstream * const bs,
440 const uint32_t value,
441 const uint32_t size)
442 {
443 uint32_t shift = 32 - bs->pos - size;
444
445 if (shift <= 32) {
446 bs->buf |= value << shift;
447 BitstreamForward(bs, size);
448 } else {
449 uint32_t remainder;
450
451 shift = size - (32 - bs->pos);
452 bs->buf |= value >> shift;
453 BitstreamForward(bs, size - shift);
454 remainder = shift;
455
456 shift = 32 - shift;
457
458 bs->buf |= value << shift;
459 BitstreamForward(bs, remainder);
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
BitstreamPad(Bitstream * const bs)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
BitstreamPadAlways(Bitstream * const bs)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_ */
500