Mercurial > audlegacy-plugins

comparison src/ffmpeg/libavcodec/bitstream.h @ 808:e8776388b02a trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn] - add ffmpeg
author nenolod
date Mon, 12 Mar 2007 11:18:54 -0700
parents
children
comparison
equal deleted inserted replaced
807:0f9c8d4d3ac4 808:e8776388b02a
1 /*
2 * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /**
22 * @file bitstream.h
23 * bitstream api header.
24 */
25
26 #ifndef BITSTREAM_H
27 #define BITSTREAM_H
28
29 #include "log.h"
30
31 #if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER)
32 #define ALT_BITSTREAM_READER
33 #endif
34
35 //#define ALT_BITSTREAM_WRITER
36 //#define ALIGNED_BITSTREAM_WRITER
37 #if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER)
38 # ifdef ARCH_ARMV4L
39 # define A32_BITSTREAM_READER
40 # else
41 #define ALT_BITSTREAM_READER
42 //#define LIBMPEG2_BITSTREAM_READER
43 //#define A32_BITSTREAM_READER
44 # endif
45 #endif
46 #define LIBMPEG2_BITSTREAM_READER_HACK //add BERO
47
48 extern const uint8_t ff_reverse[256];
49
50 #if defined(ARCH_X86) || defined(ARCH_X86_64)
51 // avoid +32 for shift optimization (gcc should do that ...)
52 static inline int32_t NEG_SSR32( int32_t a, int8_t s){
53 asm ("sarl %1, %0\n\t"
54 : "+r" (a)
55 : "ic" ((uint8_t)(-s))
56 );
57 return a;
58 }
59 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
60 asm ("shrl %1, %0\n\t"
61 : "+r" (a)
62 : "ic" ((uint8_t)(-s))
63 );
64 return a;
65 }
66 #else
67 # define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
68 # define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
69 #endif
70
71 /* bit output */
72
73 /* buf and buf_end must be present and used by every alternative writer. */
74 typedef struct PutBitContext {
75 #ifdef ALT_BITSTREAM_WRITER
76 uint8_t *buf, *buf_end;
77 int index;
78 #else
79 uint32_t bit_buf;
80 int bit_left;
81 uint8_t *buf, *buf_ptr, *buf_end;
82 #endif
83 } PutBitContext;
84
85 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
86 {
87 if(buffer_size < 0) {
88 buffer_size = 0;
89 buffer = NULL;
90 }
91
92 s->buf = buffer;
93 s->buf_end = s->buf + buffer_size;
94 #ifdef ALT_BITSTREAM_WRITER
95 s->index=0;
96 ((uint32_t*)(s->buf))[0]=0;
97 // memset(buffer, 0, buffer_size);
98 #else
99 s->buf_ptr = s->buf;
100 s->bit_left=32;
101 s->bit_buf=0;
102 #endif
103 }
104
105 /* return the number of bits output */
106 static inline int put_bits_count(PutBitContext *s)
107 {
108 #ifdef ALT_BITSTREAM_WRITER
109 return s->index;
110 #else
111 return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
112 #endif
113 }
114
115 /* pad the end of the output stream with zeros */
116 static inline void flush_put_bits(PutBitContext *s)
117 {
118 #ifdef ALT_BITSTREAM_WRITER
119 align_put_bits(s);
120 #else
121 s->bit_buf<<= s->bit_left;
122 while (s->bit_left < 32) {
123 /* XXX: should test end of buffer */
124 *s->buf_ptr++=s->bit_buf >> 24;
125 s->bit_buf<<=8;
126 s->bit_left+=8;
127 }
128 s->bit_left=32;
129 s->bit_buf=0;
130 #endif
131 }
132
133 void align_put_bits(PutBitContext *s);
134 void ff_put_string(PutBitContext * pbc, char *s, int put_zero);
135
136 /* bit input */
137 /* buffer, buffer_end and size_in_bits must be present and used by every reader */
138 typedef struct GetBitContext {
139 const uint8_t *buffer, *buffer_end;
140 #ifdef ALT_BITSTREAM_READER
141 int index;
142 #elif defined LIBMPEG2_BITSTREAM_READER
143 uint8_t *buffer_ptr;
144 uint32_t cache;
145 int bit_count;
146 #elif defined A32_BITSTREAM_READER
147 uint32_t *buffer_ptr;
148 uint32_t cache0;
149 uint32_t cache1;
150 int bit_count;
151 #endif
152 int size_in_bits;
153 } GetBitContext;
154
155 #define VLC_TYPE int16_t
156
157 typedef struct VLC {
158 int bits;
159 VLC_TYPE (*table)[2]; ///< code, bits
160 int table_size, table_allocated;
161 } VLC;
162
163 typedef struct RL_VLC_ELEM {
164 int16_t level;
165 int8_t len;
166 uint8_t run;
167 } RL_VLC_ELEM;
168
169 #if defined(ARCH_SPARC) || defined(ARCH_ARMV4L) || defined(ARCH_MIPS)
170 #define UNALIGNED_STORES_ARE_BAD
171 #endif
172
173 /* used to avoid missaligned exceptions on some archs (alpha, ...) */
174 #if defined(ARCH_X86) || defined(ARCH_X86_64)
175 # define unaligned16(a) (*(const uint16_t*)(a))
176 # define unaligned32(a) (*(const uint32_t*)(a))
177 # define unaligned64(a) (*(const uint64_t*)(a))
178 #else
179 # ifdef __GNUC__
180 # define unaligned(x) \
181 static inline uint##x##_t unaligned##x(const void *v) { \
182 struct Unaligned { \
183 uint##x##_t i; \
184 } __attribute__((packed)); \
185 \
186 return ((const struct Unaligned *) v)->i; \
187 }
188 # elif defined(__DECC)
189 # define unaligned(x) \
190 static inline uint##x##_t unaligned##x##(const void *v) { \
191 return *(const __unaligned uint##x##_t *) v; \
192 }
193 # else
194 # define unaligned(x) \
195 static inline uint##x##_t unaligned##x##(const void *v) { \
196 return *(const uint##x##_t *) v; \
197 }
198 # endif
199 unaligned(16)
200 unaligned(32)
201 unaligned(64)
202 #undef unaligned
203 #endif /* defined(ARCH_X86) || defined(ARCH_X86_64) */
204
205 #ifndef ALT_BITSTREAM_WRITER
206 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
207 {
208 unsigned int bit_buf;
209 int bit_left;
210
211 // printf("put_bits=%d %x\n", n, value);
212 assert(n == 32 || value < (1U << n));
213
214 bit_buf = s->bit_buf;
215 bit_left = s->bit_left;
216
217 // printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
218 /* XXX: optimize */
219 if (n < bit_left) {
220 bit_buf = (bit_buf<<n) | value;
221 bit_left-=n;
222 } else {
223 bit_buf<<=bit_left;
224 bit_buf |= value >> (n - bit_left);
225 #ifdef UNALIGNED_STORES_ARE_BAD
226 if (3 & (intptr_t) s->buf_ptr) {
227 s->buf_ptr[0] = bit_buf >> 24;
228 s->buf_ptr[1] = bit_buf >> 16;
229 s->buf_ptr[2] = bit_buf >> 8;
230 s->buf_ptr[3] = bit_buf ;
231 } else
232 #endif
233 *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
234 //printf("bitbuf = %08x\n", bit_buf);
235 s->buf_ptr+=4;
236 bit_left+=32 - n;
237 bit_buf = value;
238 }
239
240 s->bit_buf = bit_buf;
241 s->bit_left = bit_left;
242 }
243 #endif
244
245
246 #ifdef ALT_BITSTREAM_WRITER
247 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
248 {
249 # ifdef ALIGNED_BITSTREAM_WRITER
250 # if defined(ARCH_X86) || defined(ARCH_X86_64)
251 asm volatile(
252 "movl %0, %%ecx \n\t"
253 "xorl %%eax, %%eax \n\t"
254 "shrdl %%cl, %1, %%eax \n\t"
255 "shrl %%cl, %1 \n\t"
256 "movl %0, %%ecx \n\t"
257 "shrl $3, %%ecx \n\t"
258 "andl $0xFFFFFFFC, %%ecx \n\t"
259 "bswapl %1 \n\t"
260 "orl %1, (%2, %%ecx) \n\t"
261 "bswapl %%eax \n\t"
262 "addl %3, %0 \n\t"
263 "movl %%eax, 4(%2, %%ecx) \n\t"
264 : "=&r" (s->index), "=&r" (value)
265 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
266 : "%eax", "%ecx"
267 );
268 # else
269 int index= s->index;
270 uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
271
272 value<<= 32-n;
273
274 ptr[0] |= be2me_32(value>>(index&31));
275 ptr[1] = be2me_32(value<<(32-(index&31)));
276 //if(n>24) printf("%d %d\n", n, value);
277 index+= n;
278 s->index= index;
279 # endif
280 # else //ALIGNED_BITSTREAM_WRITER
281 # if defined(ARCH_X86) || defined(ARCH_X86_64)
282 asm volatile(
283 "movl $7, %%ecx \n\t"
284 "andl %0, %%ecx \n\t"
285 "addl %3, %%ecx \n\t"
286 "negl %%ecx \n\t"
287 "shll %%cl, %1 \n\t"
288 "bswapl %1 \n\t"
289 "movl %0, %%ecx \n\t"
290 "shrl $3, %%ecx \n\t"
291 "orl %1, (%%ecx, %2) \n\t"
292 "addl %3, %0 \n\t"
293 "movl $0, 4(%%ecx, %2) \n\t"
294 : "=&r" (s->index), "=&r" (value)
295 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
296 : "%ecx"
297 );
298 # else
299 int index= s->index;
300 uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
301
302 ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
303 ptr[1] = 0;
304 //if(n>24) printf("%d %d\n", n, value);
305 index+= n;
306 s->index= index;
307 # endif
308 # endif //!ALIGNED_BITSTREAM_WRITER
309 }
310 #endif
311
312
313 static inline uint8_t* pbBufPtr(PutBitContext *s)
314 {
315 #ifdef ALT_BITSTREAM_WRITER
316 return s->buf + (s->index>>3);
317 #else
318 return s->buf_ptr;
319 #endif
320 }
321
322 /**
323 *
324 * PutBitContext must be flushed & aligned to a byte boundary before calling this.
325 */
326 static inline void skip_put_bytes(PutBitContext *s, int n){
327 assert((put_bits_count(s)&7)==0);
328 #ifdef ALT_BITSTREAM_WRITER
329 FIXME may need some cleaning of the buffer
330 s->index += n<<3;
331 #else
332 assert(s->bit_left==32);
333 s->buf_ptr += n;
334 #endif
335 }
336
337 /**
338 * skips the given number of bits.
339 * must only be used if the actual values in the bitstream dont matter
340 */
341 static inline void skip_put_bits(PutBitContext *s, int n){
342 #ifdef ALT_BITSTREAM_WRITER
343 s->index += n;
344 #else
345 s->bit_left -= n;
346 s->buf_ptr-= s->bit_left>>5;
347 s->bit_left &= 31;
348 #endif
349 }
350
351 /**
352 * Changes the end of the buffer.
353 */
354 static inline void set_put_bits_buffer_size(PutBitContext *s, int size){
355 s->buf_end= s->buf + size;
356 }
357
358 /* Bitstream reader API docs:
359 name
360 abritary name which is used as prefix for the internal variables
361
362 gb
363 getbitcontext
364
365 OPEN_READER(name, gb)
366 loads gb into local variables
367
368 CLOSE_READER(name, gb)
369 stores local vars in gb
370
371 UPDATE_CACHE(name, gb)
372 refills the internal cache from the bitstream
373 after this call at least MIN_CACHE_BITS will be available,
374
375 GET_CACHE(name, gb)
376 will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
377
378 SHOW_UBITS(name, gb, num)
379 will return the next num bits
380
381 SHOW_SBITS(name, gb, num)
382 will return the next num bits and do sign extension
383
384 SKIP_BITS(name, gb, num)
385 will skip over the next num bits
386 note, this is equivalent to SKIP_CACHE; SKIP_COUNTER
387
388 SKIP_CACHE(name, gb, num)
389 will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
390
391 SKIP_COUNTER(name, gb, num)
392 will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
393
394 LAST_SKIP_CACHE(name, gb, num)
395 will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
396
397 LAST_SKIP_BITS(name, gb, num)
398 is equivalent to SKIP_LAST_CACHE; SKIP_COUNTER
399
400 for examples see get_bits, show_bits, skip_bits, get_vlc
401 */
402
403 static inline int unaligned32_be(const void *v)
404 {
405 #ifdef CONFIG_ALIGN
406 const uint8_t *p=v;
407 return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]);
408 #else
409 return be2me_32( unaligned32(v)); //original
410 #endif
411 }
412
413 static inline int unaligned32_le(const void *v)
414 {
415 #ifdef CONFIG_ALIGN
416 const uint8_t *p=v;
417 return (((p[3]<<8) | p[2])<<16) | (p[1]<<8) | (p[0]);
418 #else
419 return le2me_32( unaligned32(v)); //original
420 #endif
421 }
422
423 #ifdef ALT_BITSTREAM_READER
424 # define MIN_CACHE_BITS 25
425
426 # define OPEN_READER(name, gb)\
427 int name##_index= (gb)->index;\
428 int name##_cache= 0;\
429
430 # define CLOSE_READER(name, gb)\
431 (gb)->index= name##_index;\
432
433 # ifdef ALT_BITSTREAM_READER_LE
434 # define UPDATE_CACHE(name, gb)\
435 name##_cache= unaligned32_le( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\
436
437 # define SKIP_CACHE(name, gb, num)\
438 name##_cache >>= (num);
439 # else
440 # define UPDATE_CACHE(name, gb)\
441 name##_cache= unaligned32_be( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\
442
443 # define SKIP_CACHE(name, gb, num)\
444 name##_cache <<= (num);
445 # endif
446
447 // FIXME name?
448 # define SKIP_COUNTER(name, gb, num)\
449 name##_index += (num);\
450
451 # define SKIP_BITS(name, gb, num)\
452 {\
453 SKIP_CACHE(name, gb, num)\
454 SKIP_COUNTER(name, gb, num)\
455 }\
456
457 # define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
458 # define LAST_SKIP_CACHE(name, gb, num) ;
459
460 # ifdef ALT_BITSTREAM_READER_LE
461 # define SHOW_UBITS(name, gb, num)\
462 ((name##_cache) & (NEG_USR32(0xffffffff,num)))
463
464 # define SHOW_SBITS(name, gb, num)\
465 NEG_SSR32((name##_cache)<<(32-(num)), num)
466 # else
467 # define SHOW_UBITS(name, gb, num)\
468 NEG_USR32(name##_cache, num)
469
470 # define SHOW_SBITS(name, gb, num)\
471 NEG_SSR32(name##_cache, num)
472 # endif
473
474 # define GET_CACHE(name, gb)\
475 ((uint32_t)name##_cache)
476
477 static inline int get_bits_count(GetBitContext *s){
478 return s->index;
479 }
480
481 static inline void skip_bits_long(GetBitContext *s, int n){
482 s->index += n;
483 }
484
485 #elif defined LIBMPEG2_BITSTREAM_READER
486 //libmpeg2 like reader
487
488 # define MIN_CACHE_BITS 17
489
490 # define OPEN_READER(name, gb)\
491 int name##_bit_count=(gb)->bit_count;\
492 int name##_cache= (gb)->cache;\
493 uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
494
495 # define CLOSE_READER(name, gb)\
496 (gb)->bit_count= name##_bit_count;\
497 (gb)->cache= name##_cache;\
498 (gb)->buffer_ptr= name##_buffer_ptr;\
499
500 #ifdef LIBMPEG2_BITSTREAM_READER_HACK
501
502 # define UPDATE_CACHE(name, gb)\
503 if(name##_bit_count >= 0){\
504 name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\
505 name##_buffer_ptr += 2;\
506 name##_bit_count-= 16;\
507 }\
508
509 #else
510
511 # define UPDATE_CACHE(name, gb)\
512 if(name##_bit_count >= 0){\
513 name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\
514 name##_buffer_ptr+=2;\
515 name##_bit_count-= 16;\
516 }\
517
518 #endif
519
520 # define SKIP_CACHE(name, gb, num)\
521 name##_cache <<= (num);\
522
523 # define SKIP_COUNTER(name, gb, num)\
524 name##_bit_count += (num);\
525
526 # define SKIP_BITS(name, gb, num)\
527 {\
528 SKIP_CACHE(name, gb, num)\
529 SKIP_COUNTER(name, gb, num)\
530 }\
531
532 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
533 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
534
535 # define SHOW_UBITS(name, gb, num)\
536 NEG_USR32(name##_cache, num)
537
538 # define SHOW_SBITS(name, gb, num)\
539 NEG_SSR32(name##_cache, num)
540
541 # define GET_CACHE(name, gb)\
542 ((uint32_t)name##_cache)
543
544 static inline int get_bits_count(GetBitContext *s){
545 return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
546 }
547
548 static inline void skip_bits_long(GetBitContext *s, int n){
549 OPEN_READER(re, s)
550 re_bit_count += n;
551 re_buffer_ptr += 2*(re_bit_count>>4);
552 re_bit_count &= 15;
553 re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count);
554 UPDATE_CACHE(re, s)
555 CLOSE_READER(re, s)
556 }
557
558 #elif defined A32_BITSTREAM_READER
559
560 # define MIN_CACHE_BITS 32
561
562 # define OPEN_READER(name, gb)\
563 int name##_bit_count=(gb)->bit_count;\
564 uint32_t name##_cache0= (gb)->cache0;\
565 uint32_t name##_cache1= (gb)->cache1;\
566 uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
567
568 # define CLOSE_READER(name, gb)\
569 (gb)->bit_count= name##_bit_count;\
570 (gb)->cache0= name##_cache0;\
571 (gb)->cache1= name##_cache1;\
572 (gb)->buffer_ptr= name##_buffer_ptr;\
573
574 # define UPDATE_CACHE(name, gb)\
575 if(name##_bit_count > 0){\
576 const uint32_t next= be2me_32( *name##_buffer_ptr );\
577 name##_cache0 |= NEG_USR32(next,name##_bit_count);\
578 name##_cache1 |= next<<name##_bit_count;\
579 name##_buffer_ptr++;\
580 name##_bit_count-= 32;\
581 }\
582
583 #if defined(ARCH_X86) || defined(ARCH_X86_64)
584 # define SKIP_CACHE(name, gb, num)\
585 asm(\
586 "shldl %2, %1, %0 \n\t"\
587 "shll %2, %1 \n\t"\
588 : "+r" (name##_cache0), "+r" (name##_cache1)\
589 : "Ic" ((uint8_t)(num))\
590 );
591 #else
592 # define SKIP_CACHE(name, gb, num)\
593 name##_cache0 <<= (num);\
594 name##_cache0 |= NEG_USR32(name##_cache1,num);\
595 name##_cache1 <<= (num);
596 #endif
597
598 # define SKIP_COUNTER(name, gb, num)\
599 name##_bit_count += (num);\
600
601 # define SKIP_BITS(name, gb, num)\
602 {\
603 SKIP_CACHE(name, gb, num)\
604 SKIP_COUNTER(name, gb, num)\
605 }\
606
607 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
608 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
609
610 # define SHOW_UBITS(name, gb, num)\
611 NEG_USR32(name##_cache0, num)
612
613 # define SHOW_SBITS(name, gb, num)\
614 NEG_SSR32(name##_cache0, num)
615
616 # define GET_CACHE(name, gb)\
617 (name##_cache0)
618
619 static inline int get_bits_count(GetBitContext *s){
620 return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
621 }
622
623 static inline void skip_bits_long(GetBitContext *s, int n){
624 OPEN_READER(re, s)
625 re_bit_count += n;
626 re_buffer_ptr += re_bit_count>>5;
627 re_bit_count &= 31;
628 re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count;
629 re_cache1 = 0;
630 UPDATE_CACHE(re, s)
631 CLOSE_READER(re, s)
632 }
633
634 #endif
635
636 /**
637 * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
638 * if MSB not set it is negative
639 * @param n length in bits
640 * @author BERO
641 */
642 static inline int get_xbits(GetBitContext *s, int n){
643 register int sign;
644 register int32_t cache;
645 OPEN_READER(re, s)
646 UPDATE_CACHE(re, s)
647 cache = GET_CACHE(re,s);
648 sign=(~cache)>>31;
649 LAST_SKIP_BITS(re, s, n)
650 CLOSE_READER(re, s)
651 return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
652 }
653
654 static inline int get_sbits(GetBitContext *s, int n){
655 register int tmp;
656 OPEN_READER(re, s)
657 UPDATE_CACHE(re, s)
658 tmp= SHOW_SBITS(re, s, n);
659 LAST_SKIP_BITS(re, s, n)
660 CLOSE_READER(re, s)
661 return tmp;
662 }
663
664 /**
665 * reads 0-17 bits.
666 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't
667 */
668 static inline unsigned int get_bits(GetBitContext *s, int n){
669 register int tmp;
670 OPEN_READER(re, s)
671 UPDATE_CACHE(re, s)
672 tmp= SHOW_UBITS(re, s, n);
673 LAST_SKIP_BITS(re, s, n)
674 CLOSE_READER(re, s)
675 return tmp;
676 }
677
678 /**
679 * shows 0-17 bits.
680 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't
681 */
682 static inline unsigned int show_bits(GetBitContext *s, int n){
683 register int tmp;
684 OPEN_READER(re, s)
685 UPDATE_CACHE(re, s)
686 tmp= SHOW_UBITS(re, s, n);
687 // CLOSE_READER(re, s)
688 return tmp;
689 }
690
691 static inline void skip_bits(GetBitContext *s, int n){
692 //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
693 OPEN_READER(re, s)
694 UPDATE_CACHE(re, s)
695 LAST_SKIP_BITS(re, s, n)
696 CLOSE_READER(re, s)
697 }
698
699 static inline unsigned int get_bits1(GetBitContext *s){
700 #ifdef ALT_BITSTREAM_READER
701 int index= s->index;
702 uint8_t result= s->buffer[ index>>3 ];
703 #ifdef ALT_BITSTREAM_READER_LE
704 result>>= (index&0x07);
705 result&= 1;
706 #else
707 result<<= (index&0x07);
708 result>>= 8 - 1;
709 #endif
710 index++;
711 s->index= index;
712
713 return result;
714 #else
715 return get_bits(s, 1);
716 #endif
717 }
718
719 static inline unsigned int show_bits1(GetBitContext *s){
720 return show_bits(s, 1);
721 }
722
723 static inline void skip_bits1(GetBitContext *s){
724 skip_bits(s, 1);
725 }
726
727 /**
728 * reads 0-32 bits.
729 */
730 static inline unsigned int get_bits_long(GetBitContext *s, int n){
731 if(n<=17) return get_bits(s, n);
732 else{
733 #ifdef ALT_BITSTREAM_READER_LE
734 int ret= get_bits(s, 16);
735 return ret | (get_bits(s, n-16) << 16);
736 #else
737 int ret= get_bits(s, 16) << (n-16);
738 return ret | get_bits(s, n-16);
739 #endif
740 }
741 }
742
743 /**
744 * shows 0-32 bits.
745 */
746 static inline unsigned int show_bits_long(GetBitContext *s, int n){
747 if(n<=17) return show_bits(s, n);
748 else{
749 GetBitContext gb= *s;
750 int ret= get_bits_long(s, n);
751 *s= gb;
752 return ret;
753 }
754 }
755
756 static inline int check_marker(GetBitContext *s, const char *msg)
757 {
758 int bit= get_bits1(s);
759 if(!bit)
760 av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);
761
762 return bit;
763 }
764
765 /**
766 * init GetBitContext.
767 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits
768 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
769 * @param bit_size the size of the buffer in bits
770 */
771 static inline void init_get_bits(GetBitContext *s,
772 const uint8_t *buffer, int bit_size)
773 {
774 int buffer_size= (bit_size+7)>>3;
775 if(buffer_size < 0 || bit_size < 0) {
776 buffer_size = bit_size = 0;
777 buffer = NULL;
778 }
779
780 s->buffer= buffer;
781 s->size_in_bits= bit_size;
782 s->buffer_end= buffer + buffer_size;
783 #ifdef ALT_BITSTREAM_READER
784 s->index=0;
785 #elif defined LIBMPEG2_BITSTREAM_READER
786 s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1));
787 s->bit_count = 16 + 8*((intptr_t)buffer&1);
788 skip_bits_long(s, 0);
789 #elif defined A32_BITSTREAM_READER
790 s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3));
791 s->bit_count = 32 + 8*((intptr_t)buffer&3);
792 skip_bits_long(s, 0);
793 #endif
794 }
795
796 static inline void align_get_bits(GetBitContext *s)
797 {
798 int n= (-get_bits_count(s)) & 7;
799 if(n) skip_bits(s, n);
800 }
801
802 int init_vlc(VLC *vlc, int nb_bits, int nb_codes,
803 const void *bits, int bits_wrap, int bits_size,
804 const void *codes, int codes_wrap, int codes_size,
805 int flags);
806 #define INIT_VLC_USE_STATIC 1
807 #define INIT_VLC_LE 2
808 void free_vlc(VLC *vlc);
809
810 /**
811 *
812 * if the vlc code is invalid and max_depth=1 than no bits will be removed
813 * if the vlc code is invalid and max_depth>1 than the number of bits removed
814 * is undefined
815 */
816 #define GET_VLC(code, name, gb, table, bits, max_depth)\
817 {\
818 int n, index, nb_bits;\
819 \
820 index= SHOW_UBITS(name, gb, bits);\
821 code = table[index][0];\
822 n = table[index][1];\
823 \
824 if(max_depth > 1 && n < 0){\
825 LAST_SKIP_BITS(name, gb, bits)\
826 UPDATE_CACHE(name, gb)\
827 \
828 nb_bits = -n;\
829 \
830 index= SHOW_UBITS(name, gb, nb_bits) + code;\
831 code = table[index][0];\
832 n = table[index][1];\
833 if(max_depth > 2 && n < 0){\
834 LAST_SKIP_BITS(name, gb, nb_bits)\
835 UPDATE_CACHE(name, gb)\
836 \
837 nb_bits = -n;\
838 \
839 index= SHOW_UBITS(name, gb, nb_bits) + code;\
840 code = table[index][0];\
841 n = table[index][1];\
842 }\
843 }\
844 SKIP_BITS(name, gb, n)\
845 }
846
847 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\
848 {\
849 int n, index, nb_bits;\
850 \
851 index= SHOW_UBITS(name, gb, bits);\
852 level = table[index].level;\
853 n = table[index].len;\
854 \
855 if(max_depth > 1 && n < 0){\
856 SKIP_BITS(name, gb, bits)\
857 if(need_update){\
858 UPDATE_CACHE(name, gb)\
859 }\
860 \
861 nb_bits = -n;\
862 \
863 index= SHOW_UBITS(name, gb, nb_bits) + level;\
864 level = table[index].level;\
865 n = table[index].len;\
866 }\
867 run= table[index].run;\
868 SKIP_BITS(name, gb, n)\
869 }
870
871
872 /**
873 * parses a vlc code, faster then get_vlc()
874 * @param bits is the number of bits which will be read at once, must be
875 * identical to nb_bits in init_vlc()
876 * @param max_depth is the number of times bits bits must be readed to completly
877 * read the longest vlc code
878 * = (max_vlc_length + bits - 1) / bits
879 */
880 static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
881 int bits, int max_depth)
882 {
883 int code;
884
885 OPEN_READER(re, s)
886 UPDATE_CACHE(re, s)
887
888 GET_VLC(code, re, s, table, bits, max_depth)
889
890 CLOSE_READER(re, s)
891 return code;
892 }
893
894 //#define TRACE
895
896 #ifdef TRACE
897 static inline void print_bin(int bits, int n){
898 int i;
899
900 for(i=n-1; i>=0; i--){
901 av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1);
902 }
903 for(i=n; i<24; i++)
904 av_log(NULL, AV_LOG_DEBUG, " ");
905 }
906
907 static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
908 int r= get_bits(s, n);
909
910 print_bin(r, n);
911 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line);
912 return r;
913 }
914 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){
915 int show= show_bits(s, 24);
916 int pos= get_bits_count(s);
917 int r= get_vlc2(s, table, bits, max_depth);
918 int len= get_bits_count(s) - pos;
919 int bits2= show>>(24-len);
920
921 print_bin(bits2, len);
922
923 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);
924 return r;
925 }
926 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
927 int show= show_bits(s, n);
928 int r= get_xbits(s, n);
929
930 print_bin(show, n);
931 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line);
932 return r;
933 }
934
935 #define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
936 #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
937 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
938 #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
939 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
940
941 #define tprintf(...) av_log(NULL, AV_LOG_DEBUG, __VA_ARGS__)
942
943 #else //TRACE
944 #define tprintf(...) {}
945 #endif
946
947 static inline int decode012(GetBitContext *gb){
948 int n;
949 n = get_bits1(gb);
950 if (n == 0)
951 return 0;
952 else
953 return get_bits1(gb) + 1;
954 }
955
956 #endif /* BITSTREAM_H */