Mercurial > libavcodec.hg
annotate bitstream.h @ 6017:e1404acccac3 libavcodec
Actually return with an error condition if we're being asked to deal with too
many reference frames. Also check max num ref frames against our internal
ref buffer sizes.
Part of fix for roundup issue 281
author | heydowns |
---|---|
date | Fri, 14 Dec 2007 05:48:27 +0000 |
parents | 1d83e9c34641 |
children | a2b438bcb1d2 |
rev | line source |
---|---|
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
1 /* |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
2 * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at> |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
3 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3760
diff
changeset
|
4 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3760
diff
changeset
|
5 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3760
diff
changeset
|
6 * FFmpeg is free software; you can redistribute it and/or |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
7 * modify it under the terms of the GNU Lesser General Public |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
8 * License as published by the Free Software Foundation; either |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3760
diff
changeset
|
9 * version 2.1 of the License, or (at your option) any later version. |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
10 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3760
diff
changeset
|
11 * FFmpeg is distributed in the hope that it will be useful, |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
14 * Lesser General Public License for more details. |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
15 * |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
16 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3760
diff
changeset
|
17 * License along with FFmpeg; if not, write to the Free Software |
3699
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
19 */ |
c537a97eec66
Add official LGPL license headers to the files that were missing them.
diego
parents:
3675
diff
changeset
|
20 |
1106 | 21 /** |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2391
diff
changeset
|
22 * @file bitstream.h |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2391
diff
changeset
|
23 * bitstream api header. |
1106 | 24 */ |
25 | |
5830
1d83e9c34641
Add FFMPEG_ prefix to all multiple inclusion guards.
diego
parents:
5605
diff
changeset
|
26 #ifndef FFMPEG_BITSTREAM_H |
1d83e9c34641
Add FFMPEG_ prefix to all multiple inclusion guards.
diego
parents:
5605
diff
changeset
|
27 #define FFMPEG_BITSTREAM_H |
64 | 28 |
5162 | 29 #include <stdint.h> |
30 #include <stdlib.h> | |
31 #include <assert.h> | |
32 #include "common.h" | |
33 #include "bswap.h" | |
5512 | 34 #include "intreadwrite.h" |
3648
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
35 #include "log.h" |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
36 |
3649 | 37 #if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER) |
5462 | 38 # define ALT_BITSTREAM_READER |
3649 | 39 #endif |
40 | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
41 //#define ALT_BITSTREAM_WRITER |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
42 //#define ALIGNED_BITSTREAM_WRITER |
3628 | 43 #if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER) |
3650
a74c0aaf9832
use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents:
3649
diff
changeset
|
44 # ifdef ARCH_ARMV4L |
a74c0aaf9832
use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents:
3649
diff
changeset
|
45 # define A32_BITSTREAM_READER |
a74c0aaf9832
use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents:
3649
diff
changeset
|
46 # else |
5462 | 47 # define ALT_BITSTREAM_READER |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
48 //#define LIBMPEG2_BITSTREAM_READER |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
49 //#define A32_BITSTREAM_READER |
3650
a74c0aaf9832
use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents:
3649
diff
changeset
|
50 # endif |
3628 | 51 #endif |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
52 #define LIBMPEG2_BITSTREAM_READER_HACK //add BERO |
2967 | 53 |
2578 | 54 extern const uint8_t ff_reverse[256]; |
55 | |
4116 | 56 #if defined(ARCH_X86) |
525 | 57 // avoid +32 for shift optimization (gcc should do that ...) |
58 static inline int32_t NEG_SSR32( int32_t a, int8_t s){ | |
59 asm ("sarl %1, %0\n\t" | |
60 : "+r" (a) | |
61 : "ic" ((uint8_t)(-s)) | |
62 ); | |
63 return a; | |
64 } | |
65 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){ | |
66 asm ("shrl %1, %0\n\t" | |
67 : "+r" (a) | |
68 : "ic" ((uint8_t)(-s)) | |
69 ); | |
70 return a; | |
71 } | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
72 #else |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
73 # define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s))) |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
74 # define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s))) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
75 #endif |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
76 |
0 | 77 /* bit output */ |
78 | |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1886
diff
changeset
|
79 /* buf and buf_end must be present and used by every alternative writer. */ |
0 | 80 typedef struct PutBitContext { |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
81 #ifdef ALT_BITSTREAM_WRITER |
1064 | 82 uint8_t *buf, *buf_end; |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
83 int index; |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
84 #else |
1064 | 85 uint32_t bit_buf; |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
86 int bit_left; |
1064 | 87 uint8_t *buf, *buf_ptr, *buf_end; |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
88 #endif |
0 | 89 } PutBitContext; |
90 | |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
91 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
92 { |
2894
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
93 if(buffer_size < 0) { |
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
94 buffer_size = 0; |
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
95 buffer = NULL; |
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
96 } |
2889 | 97 |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
98 s->buf = buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
99 s->buf_end = s->buf + buffer_size; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
100 #ifdef ALT_BITSTREAM_WRITER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
101 s->index=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
102 ((uint32_t*)(s->buf))[0]=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
103 // memset(buffer, 0, buffer_size); |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
104 #else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
105 s->buf_ptr = s->buf; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
106 s->bit_left=32; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
107 s->bit_buf=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
108 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
109 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
110 |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
111 /* return the number of bits output */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
112 static inline int put_bits_count(PutBitContext *s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
113 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
114 #ifdef ALT_BITSTREAM_WRITER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
115 return s->index; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
116 #else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
117 return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
118 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
119 } |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
120 |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
121 /* pad the end of the output stream with zeros */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
122 static inline void flush_put_bits(PutBitContext *s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
123 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
124 #ifdef ALT_BITSTREAM_WRITER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
125 align_put_bits(s); |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
126 #else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
127 s->bit_buf<<= s->bit_left; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
128 while (s->bit_left < 32) { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
129 /* XXX: should test end of buffer */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
130 *s->buf_ptr++=s->bit_buf >> 24; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
131 s->bit_buf<<=8; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
132 s->bit_left+=8; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
133 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
134 s->bit_left=32; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
135 s->bit_buf=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
136 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
137 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
138 |
0 | 139 void align_put_bits(PutBitContext *s); |
2885
5dfb90019814
Rename put_string to ff_put_string to avoid a symbol clash on Mac OS X.
diego
parents:
2764
diff
changeset
|
140 void ff_put_string(PutBitContext * pbc, char *s, int put_zero); |
5229 | 141 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length); |
0 | 142 |
143 /* bit input */ | |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1886
diff
changeset
|
144 /* buffer, buffer_end and size_in_bits must be present and used by every reader */ |
0 | 145 typedef struct GetBitContext { |
1083 | 146 const uint8_t *buffer, *buffer_end; |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
147 #ifdef ALT_BITSTREAM_READER |
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
148 int index; |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
149 #elif defined LIBMPEG2_BITSTREAM_READER |
1064 | 150 uint8_t *buffer_ptr; |
151 uint32_t cache; | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
152 int bit_count; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
153 #elif defined A32_BITSTREAM_READER |
1064 | 154 uint32_t *buffer_ptr; |
155 uint32_t cache0; | |
156 uint32_t cache1; | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
157 int bit_count; |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
158 #endif |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
159 int size_in_bits; |
0 | 160 } GetBitContext; |
161 | |
1064 | 162 #define VLC_TYPE int16_t |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
163 |
0 | 164 typedef struct VLC { |
165 int bits; | |
1112
54be6aece1be
more cosmetics so that doxygen output is readable ...
michaelni
parents:
1106
diff
changeset
|
166 VLC_TYPE (*table)[2]; ///< code, bits |
0 | 167 int table_size, table_allocated; |
168 } VLC; | |
169 | |
542 | 170 typedef struct RL_VLC_ELEM { |
171 int16_t level; | |
172 int8_t len; | |
173 uint8_t run; | |
174 } RL_VLC_ELEM; | |
175 | |
4875 | 176 #if defined(ARCH_SPARC) || defined(ARCH_ARMV4L) || defined(ARCH_MIPS) || defined(ARCH_BFIN) |
891 | 177 #define UNALIGNED_STORES_ARE_BAD |
178 #endif | |
179 | |
5408 | 180 /* used to avoid misaligned exceptions on some archs (alpha, ...) */ |
4116 | 181 #if defined(ARCH_X86) |
3302 | 182 # define unaligned16(a) (*(const uint16_t*)(a)) |
2288 | 183 # define unaligned32(a) (*(const uint32_t*)(a)) |
3302 | 184 # define unaligned64(a) (*(const uint64_t*)(a)) |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
185 #else |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
186 # ifdef __GNUC__ |
3302 | 187 # define unaligned(x) \ |
188 static inline uint##x##_t unaligned##x(const void *v) { \ | |
189 struct Unaligned { \ | |
190 uint##x##_t i; \ | |
191 } __attribute__((packed)); \ | |
192 \ | |
193 return ((const struct Unaligned *) v)->i; \ | |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
194 } |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
195 # elif defined(__DECC) |
3302 | 196 # define unaligned(x) \ |
4288
892dba2cf52a
fix bug when __GNUC__ isn't defined and when compiling for a non-x86 architecture, patch by Martin Storsj«Ó, martin at martin st
bcoudurier
parents:
4283
diff
changeset
|
197 static inline uint##x##_t unaligned##x(const void *v) { \ |
3302 | 198 return *(const __unaligned uint##x##_t *) v; \ |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
199 } |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
200 # else |
3302 | 201 # define unaligned(x) \ |
4288
892dba2cf52a
fix bug when __GNUC__ isn't defined and when compiling for a non-x86 architecture, patch by Martin Storsj«Ó, martin at martin st
bcoudurier
parents:
4283
diff
changeset
|
202 static inline uint##x##_t unaligned##x(const void *v) { \ |
3302 | 203 return *(const uint##x##_t *) v; \ |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
204 } |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
205 # endif |
3302 | 206 unaligned(16) |
207 unaligned(32) | |
208 unaligned(64) | |
209 #undef unaligned | |
4116 | 210 #endif /* defined(ARCH_X86) */ |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
211 |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
212 #ifndef ALT_BITSTREAM_WRITER |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
213 static inline void put_bits(PutBitContext *s, int n, unsigned int value) |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
214 { |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
215 unsigned int bit_buf; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
216 int bit_left; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
217 |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
218 // printf("put_bits=%d %x\n", n, value); |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
219 assert(n == 32 || value < (1U << n)); |
2967 | 220 |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
221 bit_buf = s->bit_buf; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
222 bit_left = s->bit_left; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
223 |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
224 // printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf); |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
225 /* XXX: optimize */ |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
226 if (n < bit_left) { |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
227 bit_buf = (bit_buf<<n) | value; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
228 bit_left-=n; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
229 } else { |
2979 | 230 bit_buf<<=bit_left; |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
231 bit_buf |= value >> (n - bit_left); |
891 | 232 #ifdef UNALIGNED_STORES_ARE_BAD |
1965
f74f306c30b5
vis detection patch by (James Morrison <ja2morri at csclub dot uwaterloo dot ca>)
michael
parents:
1964
diff
changeset
|
233 if (3 & (intptr_t) s->buf_ptr) { |
891 | 234 s->buf_ptr[0] = bit_buf >> 24; |
235 s->buf_ptr[1] = bit_buf >> 16; | |
236 s->buf_ptr[2] = bit_buf >> 8; | |
237 s->buf_ptr[3] = bit_buf ; | |
238 } else | |
239 #endif | |
1064 | 240 *(uint32_t *)s->buf_ptr = be2me_32(bit_buf); |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
241 //printf("bitbuf = %08x\n", bit_buf); |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
242 s->buf_ptr+=4; |
2979 | 243 bit_left+=32 - n; |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
244 bit_buf = value; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
245 } |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
246 |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
247 s->bit_buf = bit_buf; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
248 s->bit_left = bit_left; |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
249 } |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
250 #endif |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
251 |
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
235
diff
changeset
|
252 |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
253 #ifdef ALT_BITSTREAM_WRITER |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
254 static inline void put_bits(PutBitContext *s, int n, unsigned int value) |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
255 { |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
256 # ifdef ALIGNED_BITSTREAM_WRITER |
4116 | 257 # if defined(ARCH_X86) |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
258 asm volatile( |
2979 | 259 "movl %0, %%ecx \n\t" |
260 "xorl %%eax, %%eax \n\t" | |
261 "shrdl %%cl, %1, %%eax \n\t" | |
262 "shrl %%cl, %1 \n\t" | |
263 "movl %0, %%ecx \n\t" | |
264 "shrl $3, %%ecx \n\t" | |
265 "andl $0xFFFFFFFC, %%ecx \n\t" | |
266 "bswapl %1 \n\t" | |
267 "orl %1, (%2, %%ecx) \n\t" | |
268 "bswapl %%eax \n\t" | |
269 "addl %3, %0 \n\t" | |
270 "movl %%eax, 4(%2, %%ecx) \n\t" | |
271 : "=&r" (s->index), "=&r" (value) | |
272 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n)) | |
273 : "%eax", "%ecx" | |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
274 ); |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
275 # else |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
276 int index= s->index; |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
277 uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5); |
2967 | 278 |
279 value<<= 32-n; | |
280 | |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
281 ptr[0] |= be2me_32(value>>(index&31)); |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
282 ptr[1] = be2me_32(value<<(32-(index&31))); |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
283 //if(n>24) printf("%d %d\n", n, value); |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
284 index+= n; |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
285 s->index= index; |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
286 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
287 # else //ALIGNED_BITSTREAM_WRITER |
4116 | 288 # if defined(ARCH_X86) |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
289 asm volatile( |
2979 | 290 "movl $7, %%ecx \n\t" |
291 "andl %0, %%ecx \n\t" | |
292 "addl %3, %%ecx \n\t" | |
293 "negl %%ecx \n\t" | |
294 "shll %%cl, %1 \n\t" | |
295 "bswapl %1 \n\t" | |
296 "movl %0, %%ecx \n\t" | |
297 "shrl $3, %%ecx \n\t" | |
298 "orl %1, (%%ecx, %2) \n\t" | |
299 "addl %3, %0 \n\t" | |
300 "movl $0, 4(%%ecx, %2) \n\t" | |
301 : "=&r" (s->index), "=&r" (value) | |
302 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value) | |
303 : "%ecx" | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
304 ); |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
305 # else |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
306 int index= s->index; |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
307 uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3)); |
2967 | 308 |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
309 ptr[0] |= be2me_32(value<<(32-n-(index&7) )); |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
310 ptr[1] = 0; |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
311 //if(n>24) printf("%d %d\n", n, value); |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
312 index+= n; |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
313 s->index= index; |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
314 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
315 # endif //!ALIGNED_BITSTREAM_WRITER |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
316 } |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
317 #endif |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
318 |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
319 |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
320 static inline uint8_t* pbBufPtr(PutBitContext *s) |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
321 { |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
322 #ifdef ALT_BITSTREAM_WRITER |
2979 | 323 return s->buf + (s->index>>3); |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
324 #else |
2979 | 325 return s->buf_ptr; |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
326 #endif |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
327 } |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
213
diff
changeset
|
328 |
1799 | 329 /** |
330 * | |
331 * PutBitContext must be flushed & aligned to a byte boundary before calling this. | |
332 */ | |
333 static inline void skip_put_bytes(PutBitContext *s, int n){ | |
334 assert((put_bits_count(s)&7)==0); | |
335 #ifdef ALT_BITSTREAM_WRITER | |
336 FIXME may need some cleaning of the buffer | |
2979 | 337 s->index += n<<3; |
1799 | 338 #else |
339 assert(s->bit_left==32); | |
2979 | 340 s->buf_ptr += n; |
2967 | 341 #endif |
1799 | 342 } |
343 | |
344 /** | |
5127 | 345 * Skips the given number of bits. |
346 * Must only be used if the actual values in the bitstream do not matter. | |
2502 | 347 */ |
348 static inline void skip_put_bits(PutBitContext *s, int n){ | |
349 #ifdef ALT_BITSTREAM_WRITER | |
350 s->index += n; | |
351 #else | |
352 s->bit_left -= n; | |
353 s->buf_ptr-= s->bit_left>>5; | |
354 s->bit_left &= 31; | |
2967 | 355 #endif |
2502 | 356 } |
357 | |
358 /** | |
1799 | 359 * Changes the end of the buffer. |
360 */ | |
361 static inline void set_put_bits_buffer_size(PutBitContext *s, int size){ | |
362 s->buf_end= s->buf + size; | |
363 } | |
364 | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
365 /* Bitstream reader API docs: |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
366 name |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
367 abritary name which is used as prefix for the internal variables |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
368 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
369 gb |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
370 getbitcontext |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
371 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
372 OPEN_READER(name, gb) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
373 loads gb into local variables |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
374 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
375 CLOSE_READER(name, gb) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
376 stores local vars in gb |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
377 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
378 UPDATE_CACHE(name, gb) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
379 refills the internal cache from the bitstream |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
380 after this call at least MIN_CACHE_BITS will be available, |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
381 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
382 GET_CACHE(name, gb) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
383 will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
384 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
385 SHOW_UBITS(name, gb, num) |
2764 | 386 will return the next num bits |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
387 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
388 SHOW_SBITS(name, gb, num) |
2764 | 389 will return the next num bits and do sign extension |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
390 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
391 SKIP_BITS(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
392 will skip over the next num bits |
2764 | 393 note, this is equivalent to SKIP_CACHE; SKIP_COUNTER |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
394 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
395 SKIP_CACHE(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
396 will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
397 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
398 SKIP_COUNTER(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
399 will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
400 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
401 LAST_SKIP_CACHE(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
402 will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
403 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
404 LAST_SKIP_BITS(name, gb, num) |
2764 | 405 is equivalent to SKIP_LAST_CACHE; SKIP_COUNTER |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
406 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
407 for examples see get_bits, show_bits, skip_bits, get_vlc |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
408 */ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
409 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
410 #ifdef ALT_BITSTREAM_READER |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
411 # define MIN_CACHE_BITS 25 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
412 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
413 # define OPEN_READER(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
414 int name##_index= (gb)->index;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
415 int name##_cache= 0;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
416 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
417 # define CLOSE_READER(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
418 (gb)->index= name##_index;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
419 |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
420 # ifdef ALT_BITSTREAM_READER_LE |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
421 # define UPDATE_CACHE(name, gb)\ |
5512 | 422 name##_cache= AV_RL32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\ |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
423 |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
424 # define SKIP_CACHE(name, gb, num)\ |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
425 name##_cache >>= (num); |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
426 # else |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
427 # define UPDATE_CACHE(name, gb)\ |
5512 | 428 name##_cache= AV_RB32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
429 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
430 # define SKIP_CACHE(name, gb, num)\ |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
431 name##_cache <<= (num); |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
432 # endif |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
433 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
434 // FIXME name? |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
435 # define SKIP_COUNTER(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
436 name##_index += (num);\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
437 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
438 # define SKIP_BITS(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
439 {\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
440 SKIP_CACHE(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
441 SKIP_COUNTER(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
442 }\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
443 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
444 # define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
445 # define LAST_SKIP_CACHE(name, gb, num) ; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
446 |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
447 # ifdef ALT_BITSTREAM_READER_LE |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
448 # define SHOW_UBITS(name, gb, num)\ |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
449 ((name##_cache) & (NEG_USR32(0xffffffff,num))) |
4005
3ccdff1e5221
fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents:
3947
diff
changeset
|
450 |
3ccdff1e5221
fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents:
3947
diff
changeset
|
451 # define SHOW_SBITS(name, gb, num)\ |
3ccdff1e5221
fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents:
3947
diff
changeset
|
452 NEG_SSR32((name##_cache)<<(32-(num)), num) |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
453 # else |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
454 # define SHOW_UBITS(name, gb, num)\ |
525 | 455 NEG_USR32(name##_cache, num) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
456 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
457 # define SHOW_SBITS(name, gb, num)\ |
525 | 458 NEG_SSR32(name##_cache, num) |
4005
3ccdff1e5221
fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents:
3947
diff
changeset
|
459 # endif |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
460 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
461 # define GET_CACHE(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
462 ((uint32_t)name##_cache) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
463 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
464 static inline int get_bits_count(GetBitContext *s){ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
465 return s->index; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
466 } |
3629
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
467 |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
468 static inline void skip_bits_long(GetBitContext *s, int n){ |
3633 | 469 s->index += n; |
3629
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
470 } |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
471 |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
472 #elif defined LIBMPEG2_BITSTREAM_READER |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
473 //libmpeg2 like reader |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
474 |
1263
9fce515e9894
libmpeg2 style bitstream reader 17 vs 16 bit bugfix
michaelni
parents:
1261
diff
changeset
|
475 # define MIN_CACHE_BITS 17 |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
476 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
477 # define OPEN_READER(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
478 int name##_bit_count=(gb)->bit_count;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
479 int name##_cache= (gb)->cache;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
480 uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
481 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
482 # define CLOSE_READER(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
483 (gb)->bit_count= name##_bit_count;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
484 (gb)->cache= name##_cache;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
485 (gb)->buffer_ptr= name##_buffer_ptr;\ |
0 | 486 |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
487 #ifdef LIBMPEG2_BITSTREAM_READER_HACK |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
488 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
489 # define UPDATE_CACHE(name, gb)\ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
490 if(name##_bit_count >= 0){\ |
1257 | 491 name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\ |
2614
5e24800ab329
various fixes related to the non alt_bitstream_reader
michael
parents:
2578
diff
changeset
|
492 name##_buffer_ptr += 2;\ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
493 name##_bit_count-= 16;\ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
494 }\ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
495 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
496 #else |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
497 |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
498 # define UPDATE_CACHE(name, gb)\ |
1263
9fce515e9894
libmpeg2 style bitstream reader 17 vs 16 bit bugfix
michaelni
parents:
1261
diff
changeset
|
499 if(name##_bit_count >= 0){\ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
500 name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
501 name##_buffer_ptr+=2;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
502 name##_bit_count-= 16;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
503 }\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
504 |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
505 #endif |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
506 |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
507 # define SKIP_CACHE(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
508 name##_cache <<= (num);\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
509 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
510 # define SKIP_COUNTER(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
511 name##_bit_count += (num);\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
512 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
513 # define SKIP_BITS(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
514 {\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
515 SKIP_CACHE(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
516 SKIP_COUNTER(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
517 }\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
518 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
519 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
520 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
521 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
522 # define SHOW_UBITS(name, gb, num)\ |
525 | 523 NEG_USR32(name##_cache, num) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
524 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
525 # define SHOW_SBITS(name, gb, num)\ |
525 | 526 NEG_SSR32(name##_cache, num) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
527 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
528 # define GET_CACHE(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
529 ((uint32_t)name##_cache) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
530 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
531 static inline int get_bits_count(GetBitContext *s){ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
532 return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
533 } |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
534 |
3633 | 535 static inline void skip_bits_long(GetBitContext *s, int n){ |
536 OPEN_READER(re, s) | |
537 re_bit_count += n; | |
538 re_buffer_ptr += 2*(re_bit_count>>4); | |
539 re_bit_count &= 15; | |
540 re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count); | |
541 UPDATE_CACHE(re, s) | |
542 CLOSE_READER(re, s) | |
543 } | |
544 | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
545 #elif defined A32_BITSTREAM_READER |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
546 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
547 # define MIN_CACHE_BITS 32 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
548 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
549 # define OPEN_READER(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
550 int name##_bit_count=(gb)->bit_count;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
551 uint32_t name##_cache0= (gb)->cache0;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
552 uint32_t name##_cache1= (gb)->cache1;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
553 uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
554 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
555 # define CLOSE_READER(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
556 (gb)->bit_count= name##_bit_count;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
557 (gb)->cache0= name##_cache0;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
558 (gb)->cache1= name##_cache1;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
559 (gb)->buffer_ptr= name##_buffer_ptr;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
560 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
561 # define UPDATE_CACHE(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
562 if(name##_bit_count > 0){\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
563 const uint32_t next= be2me_32( *name##_buffer_ptr );\ |
525 | 564 name##_cache0 |= NEG_USR32(next,name##_bit_count);\ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
565 name##_cache1 |= next<<name##_bit_count;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
566 name##_buffer_ptr++;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
567 name##_bit_count-= 32;\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
568 }\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
569 |
4116 | 570 #if defined(ARCH_X86) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
571 # define SKIP_CACHE(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
572 asm(\ |
2979 | 573 "shldl %2, %1, %0 \n\t"\ |
574 "shll %2, %1 \n\t"\ | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
575 : "+r" (name##_cache0), "+r" (name##_cache1)\ |
3638 | 576 : "Ic" ((uint8_t)(num))\ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
577 ); |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
578 #else |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
579 # define SKIP_CACHE(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
580 name##_cache0 <<= (num);\ |
525 | 581 name##_cache0 |= NEG_USR32(name##_cache1,num);\ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
582 name##_cache1 <<= (num); |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
583 #endif |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
584 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
585 # define SKIP_COUNTER(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
586 name##_bit_count += (num);\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
587 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
588 # define SKIP_BITS(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
589 {\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
590 SKIP_CACHE(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
591 SKIP_COUNTER(name, gb, num)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
592 }\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
593 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
594 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
595 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
596 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
597 # define SHOW_UBITS(name, gb, num)\ |
525 | 598 NEG_USR32(name##_cache0, num) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
599 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
600 # define SHOW_SBITS(name, gb, num)\ |
525 | 601 NEG_SSR32(name##_cache0, num) |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
602 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
603 # define GET_CACHE(name, gb)\ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
604 (name##_cache0) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
605 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
606 static inline int get_bits_count(GetBitContext *s){ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
607 return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
608 } |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
609 |
3629
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
610 static inline void skip_bits_long(GetBitContext *s, int n){ |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
611 OPEN_READER(re, s) |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
612 re_bit_count += n; |
3631 | 613 re_buffer_ptr += re_bit_count>>5; |
3629
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
614 re_bit_count &= 31; |
3630 | 615 re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count; |
616 re_cache1 = 0; | |
3629
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
617 UPDATE_CACHE(re, s) |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
618 CLOSE_READER(re, s) |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
619 } |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
620 |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
621 #endif |
20
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
622 |
1257 | 623 /** |
624 * read mpeg1 dc style vlc (sign bit + mantisse with no MSB). | |
2967 | 625 * if MSB not set it is negative |
1257 | 626 * @param n length in bits |
2967 | 627 * @author BERO |
1257 | 628 */ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
629 static inline int get_xbits(GetBitContext *s, int n){ |
3244 | 630 register int sign; |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
631 register int32_t cache; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
632 OPEN_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
633 UPDATE_CACHE(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
634 cache = GET_CACHE(re,s); |
3244 | 635 sign=(~cache)>>31; |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
636 LAST_SKIP_BITS(re, s, n) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
637 CLOSE_READER(re, s) |
3244 | 638 return (NEG_USR32(sign ^ cache, n) ^ sign) - sign; |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
639 } |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
640 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
641 static inline int get_sbits(GetBitContext *s, int n){ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
642 register int tmp; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
643 OPEN_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
644 UPDATE_CACHE(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
645 tmp= SHOW_SBITS(re, s, n); |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
646 LAST_SKIP_BITS(re, s, n) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
647 CLOSE_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
648 return tmp; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
649 } |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
650 |
1257 | 651 /** |
4548 | 652 * reads 1-17 bits. |
2764 | 653 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't |
1257 | 654 */ |
20
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
655 static inline unsigned int get_bits(GetBitContext *s, int n){ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
656 register int tmp; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
657 OPEN_READER(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
658 UPDATE_CACHE(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
659 tmp= SHOW_UBITS(re, s, n); |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
660 LAST_SKIP_BITS(re, s, n) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
661 CLOSE_READER(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
662 return tmp; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
663 } |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
664 |
1257 | 665 /** |
4548 | 666 * shows 1-17 bits. |
2764 | 667 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't |
1257 | 668 */ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
669 static inline unsigned int show_bits(GetBitContext *s, int n){ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
670 register int tmp; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
671 OPEN_READER(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
672 UPDATE_CACHE(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
673 tmp= SHOW_UBITS(re, s, n); |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
674 // CLOSE_READER(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
675 return tmp; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
676 } |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
677 |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
678 static inline void skip_bits(GetBitContext *s, int n){ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
679 //Note gcc seems to optimize this to s->index+=n for the ALT_READER :)) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
680 OPEN_READER(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
681 UPDATE_CACHE(re, s) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
682 LAST_SKIP_BITS(re, s, n) |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
683 CLOSE_READER(re, s) |
20
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
684 } |
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
685 |
21 | 686 static inline unsigned int get_bits1(GetBitContext *s){ |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
687 #ifdef ALT_BITSTREAM_READER |
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
688 int index= s->index; |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
689 uint8_t result= s->buffer[ index>>3 ]; |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
690 #ifdef ALT_BITSTREAM_READER_LE |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
691 result>>= (index&0x07); |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
692 result&= 1; |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
693 #else |
199
0f1dba8fc617
(commited by michael / arpi was crazy enough to give me his password)
arpi_esp
parents:
193
diff
changeset
|
694 result<<= (index&0x07); |
0f1dba8fc617
(commited by michael / arpi was crazy enough to give me his password)
arpi_esp
parents:
193
diff
changeset
|
695 result>>= 8 - 1; |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
696 #endif |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
697 index++; |
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
698 s->index= index; |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
699 |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
700 return result; |
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
701 #else |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
702 return get_bits(s, 1); |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
703 #endif |
21 | 704 } |
705 | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
706 static inline unsigned int show_bits1(GetBitContext *s){ |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
707 return show_bits(s, 1); |
21 | 708 } |
709 | |
710 static inline void skip_bits1(GetBitContext *s){ | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
517
diff
changeset
|
711 skip_bits(s, 1); |
21 | 712 } |
713 | |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
714 /** |
3648
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
715 * reads 0-32 bits. |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
716 */ |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
717 static inline unsigned int get_bits_long(GetBitContext *s, int n){ |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
718 if(n<=17) return get_bits(s, n); |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
719 else{ |
3760
dbe7b99efdbf
Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents:
3699
diff
changeset
|
720 #ifdef ALT_BITSTREAM_READER_LE |
dbe7b99efdbf
Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents:
3699
diff
changeset
|
721 int ret= get_bits(s, 16); |
dbe7b99efdbf
Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents:
3699
diff
changeset
|
722 return ret | (get_bits(s, n-16) << 16); |
dbe7b99efdbf
Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents:
3699
diff
changeset
|
723 #else |
3648
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
724 int ret= get_bits(s, 16) << (n-16); |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
725 return ret | get_bits(s, n-16); |
3760
dbe7b99efdbf
Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents:
3699
diff
changeset
|
726 #endif |
3648
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
727 } |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
728 } |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
729 |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
730 /** |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
731 * shows 0-32 bits. |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
732 */ |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
733 static inline unsigned int show_bits_long(GetBitContext *s, int n){ |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
734 if(n<=17) return show_bits(s, n); |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
735 else{ |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
736 GetBitContext gb= *s; |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
737 int ret= get_bits_long(s, n); |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
738 *s= gb; |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
739 return ret; |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
740 } |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
741 } |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
742 |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
743 static inline int check_marker(GetBitContext *s, const char *msg) |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
744 { |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
745 int bit= get_bits1(s); |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
746 if(!bit) |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
747 av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg); |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
748 |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
749 return bit; |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
750 } |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
751 |
c44d798b06b5
move some functions to bitstream.h to avoid conflicts
aurel
parents:
3638
diff
changeset
|
752 /** |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
753 * init GetBitContext. |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
754 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
755 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
756 * @param bit_size the size of the buffer in bits |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
757 */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
758 static inline void init_get_bits(GetBitContext *s, |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
759 const uint8_t *buffer, int bit_size) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
760 { |
2889 | 761 int buffer_size= (bit_size+7)>>3; |
2894
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
762 if(buffer_size < 0 || bit_size < 0) { |
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
763 buffer_size = bit_size = 0; |
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
764 buffer = NULL; |
26f8974c3d66
fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents:
2889
diff
changeset
|
765 } |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
766 |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
767 s->buffer= buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
768 s->size_in_bits= bit_size; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
769 s->buffer_end= buffer + buffer_size; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
770 #ifdef ALT_BITSTREAM_READER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
771 s->index=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
772 #elif defined LIBMPEG2_BITSTREAM_READER |
3633 | 773 s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1)); |
774 s->bit_count = 16 + 8*((intptr_t)buffer&1); | |
775 skip_bits_long(s, 0); | |
3632
25ceb2cc950d
make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents:
3631
diff
changeset
|
776 #elif defined A32_BITSTREAM_READER |
25ceb2cc950d
make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents:
3631
diff
changeset
|
777 s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3)); |
25ceb2cc950d
make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents:
3631
diff
changeset
|
778 s->bit_count = 32 + 8*((intptr_t)buffer&3); |
25ceb2cc950d
make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents:
3631
diff
changeset
|
779 skip_bits_long(s, 0); |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
780 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
781 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
782 |
3675 | 783 static inline void align_get_bits(GetBitContext *s) |
3629
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
784 { |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
785 int n= (-get_bits_count(s)) & 7; |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
786 if(n) skip_bits(s, n); |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
787 } |
2ab6ec6259b1
move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents:
3628
diff
changeset
|
788 |
5071
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
789 #define init_vlc(vlc, nb_bits, nb_codes,\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
790 bits, bits_wrap, bits_size,\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
791 codes, codes_wrap, codes_size,\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
792 flags)\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
793 init_vlc_sparse(vlc, nb_bits, nb_codes,\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
794 bits, bits_wrap, bits_size,\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
795 codes, codes_wrap, codes_size,\ |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
796 NULL, 0, 0, flags) |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
797 |
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
798 int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, |
0 | 799 const void *bits, int bits_wrap, int bits_size, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2318
diff
changeset
|
800 const void *codes, int codes_wrap, int codes_size, |
5071
0d503c12092b
add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents:
4875
diff
changeset
|
801 const void *symbols, int symbols_wrap, int symbols_size, |
2663
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
802 int flags); |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
803 #define INIT_VLC_USE_STATIC 1 |
b33be8b00488
LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents:
2615
diff
changeset
|
804 #define INIT_VLC_LE 2 |
0 | 805 void free_vlc(VLC *vlc); |
806 | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
807 /** |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
808 * |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
809 * if the vlc code is invalid and max_depth=1 than no bits will be removed |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
810 * if the vlc code is invalid and max_depth>1 than the number of bits removed |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
811 * is undefined |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
994
diff
changeset
|
812 */ |
529 | 813 #define GET_VLC(code, name, gb, table, bits, max_depth)\ |
814 {\ | |
815 int n, index, nb_bits;\ | |
816 \ | |
817 index= SHOW_UBITS(name, gb, bits);\ | |
818 code = table[index][0];\ | |
819 n = table[index][1];\ | |
820 \ | |
821 if(max_depth > 1 && n < 0){\ | |
822 LAST_SKIP_BITS(name, gb, bits)\ | |
823 UPDATE_CACHE(name, gb)\ | |
824 \ | |
825 nb_bits = -n;\ | |
826 \ | |
535 | 827 index= SHOW_UBITS(name, gb, nb_bits) + code;\ |
529 | 828 code = table[index][0];\ |
829 n = table[index][1];\ | |
830 if(max_depth > 2 && n < 0){\ | |
831 LAST_SKIP_BITS(name, gb, nb_bits)\ | |
832 UPDATE_CACHE(name, gb)\ | |
833 \ | |
834 nb_bits = -n;\ | |
835 \ | |
535 | 836 index= SHOW_UBITS(name, gb, nb_bits) + code;\ |
529 | 837 code = table[index][0];\ |
838 n = table[index][1];\ | |
839 }\ | |
840 }\ | |
841 SKIP_BITS(name, gb, n)\ | |
842 } | |
843 | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2614
diff
changeset
|
844 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\ |
542 | 845 {\ |
846 int n, index, nb_bits;\ | |
847 \ | |
848 index= SHOW_UBITS(name, gb, bits);\ | |
849 level = table[index].level;\ | |
850 n = table[index].len;\ | |
851 \ | |
852 if(max_depth > 1 && n < 0){\ | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2614
diff
changeset
|
853 SKIP_BITS(name, gb, bits)\ |
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2614
diff
changeset
|
854 if(need_update){\ |
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2614
diff
changeset
|
855 UPDATE_CACHE(name, gb)\ |
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2614
diff
changeset
|
856 }\ |
542 | 857 \ |
858 nb_bits = -n;\ | |
859 \ | |
860 index= SHOW_UBITS(name, gb, nb_bits) + level;\ | |
861 level = table[index].level;\ | |
862 n = table[index].len;\ | |
863 }\ | |
864 run= table[index].run;\ | |
865 SKIP_BITS(name, gb, n)\ | |
866 } | |
867 | |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
868 |
1079 | 869 /** |
870 * parses a vlc code, faster then get_vlc() | |
2967 | 871 * @param bits is the number of bits which will be read at once, must be |
1079 | 872 * identical to nb_bits in init_vlc() |
4795 | 873 * @param max_depth is the number of times bits bits must be read to completely |
2967 | 874 * read the longest vlc code |
1079 | 875 * = (max_vlc_length + bits - 1) / bits |
876 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4116
diff
changeset
|
877 static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2], |
550 | 878 int bits, int max_depth) |
531 | 879 { |
880 int code; | |
2967 | 881 |
531 | 882 OPEN_READER(re, s) |
883 UPDATE_CACHE(re, s) | |
884 | |
885 GET_VLC(code, re, s, table, bits, max_depth) | |
886 | |
887 CLOSE_READER(re, s) | |
888 return code; | |
889 } | |
890 | |
1147 | 891 //#define TRACE |
892 | |
893 #ifdef TRACE | |
894 static inline void print_bin(int bits, int n){ | |
895 int i; | |
2967 | 896 |
1147 | 897 for(i=n-1; i>=0; i--){ |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
898 av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1); |
1147 | 899 } |
900 for(i=n; i<24; i++) | |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
901 av_log(NULL, AV_LOG_DEBUG, " "); |
1147 | 902 } |
903 | |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
904 static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){ |
1147 | 905 int r= get_bits(s, n); |
2967 | 906 |
1147 | 907 print_bin(r, n); |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
908 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); |
1147 | 909 return r; |
910 } | |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
911 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){ |
1147 | 912 int show= show_bits(s, 24); |
913 int pos= get_bits_count(s); | |
914 int r= get_vlc2(s, table, bits, max_depth); | |
915 int len= get_bits_count(s) - pos; | |
916 int bits2= show>>(24-len); | |
2967 | 917 |
1147 | 918 print_bin(bits2, len); |
2967 | 919 |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
920 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line); |
1147 | 921 return r; |
922 } | |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
923 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){ |
1273 | 924 int show= show_bits(s, n); |
925 int r= get_xbits(s, n); | |
2967 | 926 |
1273 | 927 print_bin(show, n); |
2438
e98b5e0de86b
compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2398
diff
changeset
|
928 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); |
1273 | 929 return r; |
930 } | |
1147 | 931 |
932 #define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
933 #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
1273 | 934 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) |
1152 | 935 #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__) |
1147 | 936 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__) |
937 | |
4600 | 938 #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__) |
1170 | 939 |
940 #else //TRACE | |
4600 | 941 #define tprintf(p, ...) {} |
1170 | 942 #endif |
542 | 943 |
2467 | 944 static inline int decode012(GetBitContext *gb){ |
2464 | 945 int n; |
946 n = get_bits1(gb); | |
947 if (n == 0) | |
948 return 0; | |
949 else | |
950 return get_bits1(gb) + 1; | |
951 } | |
952 | |
5830
1d83e9c34641
Add FFMPEG_ prefix to all multiple inclusion guards.
diego
parents:
5605
diff
changeset
|
953 #endif /* FFMPEG_BITSTREAM_H */ |