Mercurial > libavcodec.hg
annotate common.h @ 2319:f9f257b41ec2 libavcodec
mjpeg parser
author | michael |
---|---|
date | Sun, 24 Oct 2004 22:37:29 +0000 |
parents | 1925d732ea42 |
children | 26560d4fdb1f |
rev | line source |
---|---|
1106 | 1 /** |
2 * @file common.h | |
3 * common internal api header. | |
4 */ | |
5 | |
0 | 6 #ifndef COMMON_H |
7 #define COMMON_H | |
8 | |
213
e80ad397d30e
Cygwin's mangling by Felix Buenemann <atmosfear@users.sourceforge.net>
nickols_k
parents:
199
diff
changeset
|
9 #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
10 # define CONFIG_WIN32 |
64 | 11 #endif |
12 | |
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
|
13 //#define ALT_BITSTREAM_WRITER |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
14 //#define ALIGNED_BITSTREAM_WRITER |
512
ba67fefada47
Activate ALT_BITSTREAM_READER by default on Alpha, since it seems to
mellum
parents:
496
diff
changeset
|
15 |
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
|
16 #define 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
|
17 //#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
|
18 //#define A32_BITSTREAM_READER |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
19 #define LIBMPEG2_BITSTREAM_READER_HACK //add BERO |
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
|
20 |
1758
d49aae2f9027
freebsd fix for mpeg12.c (moving INT64_MAX to common.h)
alex
parents:
1756
diff
changeset
|
21 #ifndef M_PI |
d49aae2f9027
freebsd fix for mpeg12.c (moving INT64_MAX to common.h)
alex
parents:
1756
diff
changeset
|
22 #define M_PI 3.14159265358979323846 |
d49aae2f9027
freebsd fix for mpeg12.c (moving INT64_MAX to common.h)
alex
parents:
1756
diff
changeset
|
23 #endif |
d49aae2f9027
freebsd fix for mpeg12.c (moving INT64_MAX to common.h)
alex
parents:
1756
diff
changeset
|
24 |
10 | 25 #ifdef HAVE_AV_CONFIG_H |
64 | 26 /* only include the following when compiling package */ |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
27 # include "config.h" |
64 | 28 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
29 # include <stdlib.h> |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
30 # include <stdio.h> |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
31 # include <string.h> |
1444 | 32 # include <ctype.h> |
2112 | 33 # include <limits.h> |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
34 # ifndef __BEOS__ |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
35 # include <errno.h> |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
36 # else |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
37 # include "berrno.h" |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
38 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
39 # include <math.h> |
64 | 40 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
41 # ifndef ENODATA |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
42 # define ENODATA 61 |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
43 # endif |
0 | 44 |
1059 | 45 #include <stddef.h> |
46 #ifndef offsetof | |
47 # define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F)) | |
48 #endif | |
49 | |
50 #define AVOPTION_CODEC_BOOL(name, help, field) \ | |
51 { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_BOOL } | |
1130 | 52 #define AVOPTION_CODEC_DOUBLE(name, help, field, minv, maxv, defval) \ |
53 { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_DOUBLE, minv, maxv, defval } | |
1059 | 54 #define AVOPTION_CODEC_FLAG(name, help, field, flag, defval) \ |
55 { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_FLAG, flag, 0, defval } | |
56 #define AVOPTION_CODEC_INT(name, help, field, minv, maxv, defval) \ | |
57 { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_INT, minv, maxv, defval } | |
58 #define AVOPTION_CODEC_STRING(name, help, field, str, val) \ | |
59 { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_STRING, .defval = val, .defstr = str } | |
60 #define AVOPTION_CODEC_RCOVERRIDE(name, help, field) \ | |
61 { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_RCOVERRIDE, .defval = 0, .defstr = NULL } | |
1114 | 62 #define AVOPTION_SUB(ptr) { .name = NULL, .help = (const char*)ptr } |
1059 | 63 #define AVOPTION_END() AVOPTION_SUB(NULL) |
64 | |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
65 struct AVOption; |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
66 #ifdef HAVE_MMX |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
67 extern const struct AVOption avoptions_common[3 + 5]; |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
68 #else |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
69 extern const struct AVOption avoptions_common[3]; |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
70 #endif |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
71 extern const struct AVOption avoptions_workaround_bug[11]; |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1118
diff
changeset
|
72 |
390
48e08d9871da
added proper memory handling functions - fixed include paths
glantau
parents:
370
diff
changeset
|
73 #endif /* HAVE_AV_CONFIG_H */ |
64 | 74 |
517 | 75 /* Suppress restrict if it was not defined in config.h. */ |
76 #ifndef restrict | |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
77 # define restrict |
517 | 78 #endif |
79 | |
1982 | 80 #ifndef always_inline |
550 | 81 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
82 # define always_inline __attribute__((always_inline)) inline |
550 | 83 #else |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
84 # define always_inline inline |
550 | 85 #endif |
1982 | 86 #endif |
550 | 87 |
1982 | 88 #ifndef attribute_used |
1845
3054613980a8
attribute used patch by (mitya at school dot ioffe dot ru (Dmitry Baryshkov))
michael
parents:
1840
diff
changeset
|
89 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) |
3054613980a8
attribute used patch by (mitya at school dot ioffe dot ru (Dmitry Baryshkov))
michael
parents:
1840
diff
changeset
|
90 # define attribute_used __attribute__((used)) |
3054613980a8
attribute used patch by (mitya at school dot ioffe dot ru (Dmitry Baryshkov))
michael
parents:
1840
diff
changeset
|
91 #else |
3054613980a8
attribute used patch by (mitya at school dot ioffe dot ru (Dmitry Baryshkov))
michael
parents:
1840
diff
changeset
|
92 # define attribute_used |
3054613980a8
attribute used patch by (mitya at school dot ioffe dot ru (Dmitry Baryshkov))
michael
parents:
1840
diff
changeset
|
93 #endif |
1982 | 94 #endif |
1845
3054613980a8
attribute used patch by (mitya at school dot ioffe dot ru (Dmitry Baryshkov))
michael
parents:
1840
diff
changeset
|
95 |
1738
378e98870df4
more sane inttypes emulation behavior if libavcodec is used outside ffmpeg
michael
parents:
1735
diff
changeset
|
96 #ifndef EMULATE_INTTYPES |
1735
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
97 # include <inttypes.h> |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
98 #else |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
99 typedef signed char int8_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
100 typedef signed short int16_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
101 typedef signed int int32_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
102 typedef unsigned char uint8_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
103 typedef unsigned short uint16_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
104 typedef unsigned int uint32_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
105 |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
106 # ifdef CONFIG_WIN32 |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
107 typedef signed __int64 int64_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
108 typedef unsigned __int64 uint64_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
109 # else /* other OS */ |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
110 typedef signed long long int64_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
111 typedef unsigned long long uint64_t; |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
112 # endif /* other OS */ |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
113 #endif /* HAVE_INTTYPES_H */ |
cb0abe523bc6
inttypes emulation cleanup patch by ("Chris Flerackers" <cflerackers at androme dot be>)
michael
parents:
1660
diff
changeset
|
114 |
2318
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
115 #ifndef INT16_MIN |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
116 #define INT16_MIN (-0x7fff-1) |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
117 #endif |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
118 |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
119 #ifndef INT16_MAX |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
120 #define INT16_MAX 0x7fff |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
121 #endif |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
122 |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
123 #ifndef INT64_MIN |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
124 #define INT64_MIN (-0x7fffffffffffffffLL-1) |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
125 #endif |
1925d732ea42
INT MIN/MAX patch by (Bohdan Horst <nexus at irc dot pl>)
michael
parents:
2293
diff
changeset
|
126 |
1761
3620e301643a
int64max fix by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1758
diff
changeset
|
127 #ifndef INT64_MAX |
1840
0287241a0c18
int64_t_C patch by (Gael Chardon <gael-announcements+ffmpeg at 4now dot net>)
michael
parents:
1824
diff
changeset
|
128 #define INT64_MAX int64_t_C(9223372036854775807) |
1761
3620e301643a
int64max fix by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1758
diff
changeset
|
129 #endif |
3620e301643a
int64max fix by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1758
diff
changeset
|
130 |
2016 | 131 #ifndef UINT64_MAX |
132 #define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF) | |
133 #endif | |
134 | |
1603
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
135 #ifdef EMULATE_FAST_INT |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
136 /* note that we don't emulate 64bit ints */ |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
137 typedef signed char int_fast8_t; |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
138 typedef signed int int_fast16_t; |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
139 typedef signed int int_fast32_t; |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
140 typedef unsigned char uint_fast8_t; |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
141 typedef unsigned int uint_fast16_t; |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
142 typedef unsigned int uint_fast32_t; |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
143 #endif |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
144 |
2093 | 145 #ifndef INT_BIT |
2112 | 146 # if INT_MAX != 2147483647 |
2093 | 147 # define INT_BIT 64 |
148 # else | |
149 # define INT_BIT 32 | |
150 # endif | |
151 #endif | |
152 | |
1603
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
153 #if defined(CONFIG_OS2) || defined(CONFIG_SUNOS) |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
154 static inline float floorf(float f) { |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
155 return floor(f); |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
156 } |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
157 #endif |
3a633a3feef6
* fixes for broken builds on Solaris, OS2 and all bingendian
romansh
parents:
1598
diff
changeset
|
158 |
64 | 159 #ifdef CONFIG_WIN32 |
160 | |
161 /* windows */ | |
162 | |
1961
603d4a0e974c
libavcodec Cygwin compilation failure (II) patch by (Sascha Sommer)
michael
parents:
1954
diff
changeset
|
163 # if !defined(__MINGW32__) && !defined(__CYGWIN__) |
1064 | 164 # define int64_t_C(c) (c ## i64) |
165 # define uint64_t_C(c) (c ## i64) | |
64 | 166 |
1509 | 167 # ifdef HAVE_AV_CONFIG_H |
168 # define inline __inline | |
169 # endif | |
64 | 170 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
171 # else |
1064 | 172 # define int64_t_C(c) (c ## LL) |
173 # define uint64_t_C(c) (c ## ULL) | |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
174 # endif /* __MINGW32__ */ |
76 | 175 |
1509 | 176 # ifdef HAVE_AV_CONFIG_H |
177 # ifdef _DEBUG | |
178 # define DEBUG | |
179 # endif | |
180 | |
181 # define snprintf _snprintf | |
182 # define vsnprintf _vsnprintf | |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
183 # endif |
64 | 184 |
994
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
185 /* CONFIG_WIN32 end */ |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
186 #elif defined (CONFIG_OS2) |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
187 /* OS/2 EMX */ |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
188 |
1064 | 189 #ifndef int64_t_C |
190 #define int64_t_C(c) (c ## LL) | |
191 #define uint64_t_C(c) (c ## ULL) | |
994
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
192 #endif |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
193 |
1413 | 194 #ifdef HAVE_AV_CONFIG_H |
195 | |
994
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
196 #ifdef USE_FASTMEMCPY |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
197 #include "fastmemcpy.h" |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
198 #endif |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
199 |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
200 #include <float.h> |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
201 |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
202 #endif /* HAVE_AV_CONFIG_H */ |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
203 |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
204 /* CONFIG_OS2 end */ |
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
205 #else |
64 | 206 |
207 /* unix */ | |
208 | |
1413 | 209 #ifndef int64_t_C |
210 #define int64_t_C(c) (c ## LL) | |
211 #define uint64_t_C(c) (c ## ULL) | |
212 #endif | |
213 | |
214 #ifdef HAVE_AV_CONFIG_H | |
64 | 215 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
216 # ifdef USE_FASTMEMCPY |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
217 # include "fastmemcpy.h" |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
218 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
219 # endif /* HAVE_AV_CONFIG_H */ |
76 | 220 |
994
7701ff462e3a
os2 support patch by ("Slavik Gnatenko" <miracle9 at newmail dot ru>)
michaelni
parents:
976
diff
changeset
|
221 #endif /* !CONFIG_WIN32 && !CONFIG_OS2 */ |
76 | 222 |
488 | 223 #ifdef HAVE_AV_CONFIG_H |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
224 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
225 # include "bswap.h" |
426 | 226 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
227 # if defined(__MINGW32__) || defined(__CYGWIN__) || \ |
1226
dbc7e3c814a9
Tiny patch for OpenBSD by (Bj«Órn Sandell <biorn at dce dot chalmers dot se>)
michaelni
parents:
1177
diff
changeset
|
228 defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__)) |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
229 # define MANGLE(a) "_" #a |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
230 # else |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
231 # define MANGLE(a) #a |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
232 # endif |
432 | 233 |
76 | 234 /* debug stuff */ |
235 | |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
236 # ifndef DEBUG |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
237 # define NDEBUG |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
238 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
239 # include <assert.h> |
64 | 240 |
76 | 241 /* dprintf macros */ |
1964
2b16a3c32318
cygwin patch by ("Sascha Sommer" <saschasommer at freenet dot de>)
michael
parents:
1961
diff
changeset
|
242 # if defined(CONFIG_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) |
76 | 243 |
244 inline void dprintf(const char* fmt,...) {} | |
245 | |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
246 # else |
76 | 247 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
248 # ifdef DEBUG |
1940 | 249 # define dprintf(fmt,...) av_log(NULL, AV_LOG_DEBUG, fmt, __VA_ARGS__) |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
250 # else |
1545
b340e83b8d0d
gcc->C99 and warning fixes patch by (Dan Christiansen <danchr at daimi dot au dot dk>)
michael
parents:
1522
diff
changeset
|
251 # define dprintf(fmt,...) |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
252 # endif |
64 | 253 |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
254 # endif /* !CONFIG_WIN32 */ |
64 | 255 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
256 # define av_abort() do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0) |
423
ed6098c4216a
Add an av_abort macro that aborts, but also prints out the location of the abort.
philipjsg
parents:
408
diff
changeset
|
257 |
753 | 258 //rounded divison & shift |
1954 | 259 #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) |
344 | 260 /* assume b>0 */ |
261 #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) | |
359 | 262 #define ABS(a) ((a) >= 0 ? (a) : (-(a))) |
823 | 263 |
847 | 264 #define FFMAX(a,b) ((a) > (b) ? (a) : (b)) |
265 #define FFMIN(a,b) ((a) > (b) ? (b) : (a)) | |
344 | 266 |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
267 extern const uint32_t inverse[256]; |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
268 |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
269 #if defined(ARCH_X86) || defined(ARCH_X86_64) |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
270 # define FASTDIV(a,b) \ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
271 ({\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
272 int ret,dmy;\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
273 asm volatile(\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
274 "mull %3"\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
275 :"=d"(ret),"=a"(dmy)\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
276 :"1"(a),"g"(inverse[b])\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
277 );\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
278 ret;\ |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
279 }) |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
280 #elif defined(CONFIG_FASTDIV) |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
281 # define FASTDIV(a,b) ((uint32_t)((((uint64_t)a)*inverse[b])>>32)) |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
282 #else |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
283 # define FASTDIV(a,b) ((a)/(b)) |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
284 #endif |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
285 |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
286 #if defined(ARCH_X86) || defined(ARCH_X86_64) |
525 | 287 // avoid +32 for shift optimization (gcc should do that ...) |
288 static inline int32_t NEG_SSR32( int32_t a, int8_t s){ | |
289 asm ("sarl %1, %0\n\t" | |
290 : "+r" (a) | |
291 : "ic" ((uint8_t)(-s)) | |
292 ); | |
293 return a; | |
294 } | |
295 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){ | |
296 asm ("shrl %1, %0\n\t" | |
297 : "+r" (a) | |
298 : "ic" ((uint8_t)(-s)) | |
299 ); | |
300 return a; | |
301 } | |
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
|
302 #else |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
303 # define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s))) |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
304 # 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
|
305 #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
|
306 |
0 | 307 /* bit output */ |
308 | |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1886
diff
changeset
|
309 /* buf and buf_end must be present and used by every alternative writer. */ |
0 | 310 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
|
311 #ifdef ALT_BITSTREAM_WRITER |
1064 | 312 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
|
313 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
|
314 #else |
1064 | 315 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
|
316 int bit_left; |
1064 | 317 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
|
318 #endif |
0 | 319 } PutBitContext; |
320 | |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
321 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
|
322 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
323 s->buf = buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
324 s->buf_end = s->buf + buffer_size; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
325 #ifdef ALT_BITSTREAM_WRITER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
326 s->index=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
327 ((uint32_t*)(s->buf))[0]=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
328 // memset(buffer, 0, buffer_size); |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
329 #else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
330 s->buf_ptr = s->buf; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
331 s->bit_left=32; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
332 s->bit_buf=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
333 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
334 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
335 |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
336 /* return the number of bits output */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
337 static inline int put_bits_count(PutBitContext *s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
338 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
339 #ifdef ALT_BITSTREAM_WRITER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
340 return s->index; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
341 #else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
342 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
|
343 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
344 } |
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
|
345 |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
346 /* 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
|
347 static inline void flush_put_bits(PutBitContext *s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
348 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
349 #ifdef ALT_BITSTREAM_WRITER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
350 align_put_bits(s); |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
351 #else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
352 s->bit_buf<<= s->bit_left; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
353 while (s->bit_left < 32) { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
354 /* XXX: should test end of buffer */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
355 *s->buf_ptr++=s->bit_buf >> 24; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
356 s->bit_buf<<=8; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
357 s->bit_left+=8; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
358 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
359 s->bit_left=32; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
360 s->bit_buf=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
361 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
362 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
363 |
0 | 364 void align_put_bits(PutBitContext *s); |
1795 | 365 void put_string(PutBitContext * pbc, char *s, int put_zero); |
0 | 366 |
367 /* bit input */ | |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1886
diff
changeset
|
368 /* buffer, buffer_end and size_in_bits must be present and used by every reader */ |
0 | 369 typedef struct GetBitContext { |
1083 | 370 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
|
371 #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
|
372 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
|
373 #elif defined LIBMPEG2_BITSTREAM_READER |
1064 | 374 uint8_t *buffer_ptr; |
375 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
|
376 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
|
377 #elif defined A32_BITSTREAM_READER |
1064 | 378 uint32_t *buffer_ptr; |
379 uint32_t cache0; | |
380 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
|
381 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
|
382 #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
|
383 int size_in_bits; |
0 | 384 } GetBitContext; |
385 | |
1064 | 386 #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
|
387 |
0 | 388 typedef struct VLC { |
389 int bits; | |
1112
54be6aece1be
more cosmetics so that doxygen output is readable ...
michaelni
parents:
1106
diff
changeset
|
390 VLC_TYPE (*table)[2]; ///< code, bits |
0 | 391 int table_size, table_allocated; |
392 } VLC; | |
393 | |
542 | 394 typedef struct RL_VLC_ELEM { |
395 int16_t level; | |
396 int8_t len; | |
397 uint8_t run; | |
398 } RL_VLC_ELEM; | |
399 | |
1965
f74f306c30b5
vis detection patch by (James Morrison <ja2morri at csclub dot uwaterloo dot ca>)
michael
parents:
1964
diff
changeset
|
400 #ifdef ARCH_SPARC |
891 | 401 #define UNALIGNED_STORES_ARE_BAD |
402 #endif | |
403 | |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
404 /* used to avoid missaligned exceptions on some archs (alpha, ...) */ |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
405 #if defined(ARCH_X86) || defined(ARCH_X86_64) |
2288 | 406 # define unaligned32(a) (*(const uint32_t*)(a)) |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
407 #else |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
408 # ifdef __GNUC__ |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
409 static inline uint32_t unaligned32(const void *v) { |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
410 struct Unaligned { |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
411 uint32_t i; |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
412 } __attribute__((packed)); |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
413 |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
414 return ((const struct Unaligned *) v)->i; |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
415 } |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
416 # elif defined(__DECC) |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
417 static inline uint32_t unaligned32(const void *v) { |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
418 return *(const __unaligned uint32_t *) v; |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
419 } |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
420 # else |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
421 static inline uint32_t unaligned32(const void *v) { |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
422 return *(const uint32_t *) v; |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
423 } |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
424 # endif |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
425 #endif //!ARCH_X86 |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
426 |
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
|
427 #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
|
428 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
|
429 { |
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
|
430 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
|
431 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
|
432 |
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
|
433 #ifdef STATS |
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
|
434 st_out_bit_counts[st_current_index] += 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
|
435 #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
|
436 // 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
|
437 assert(n == 32 || value < (1U << n)); |
306 | 438 |
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
|
439 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
|
440 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
|
441 |
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
|
442 // 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
|
443 /* 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
|
444 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
|
445 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
|
446 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
|
447 } else { |
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
|
448 bit_buf<<=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
|
449 bit_buf |= value >> (n - bit_left); |
891 | 450 #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
|
451 if (3 & (intptr_t) s->buf_ptr) { |
891 | 452 s->buf_ptr[0] = bit_buf >> 24; |
453 s->buf_ptr[1] = bit_buf >> 16; | |
454 s->buf_ptr[2] = bit_buf >> 8; | |
455 s->buf_ptr[3] = bit_buf ; | |
456 } else | |
457 #endif | |
1064 | 458 *(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
|
459 //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
|
460 s->buf_ptr+=4; |
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
|
461 bit_left+=32 - 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
|
462 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
|
463 } |
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
|
464 |
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
|
465 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
|
466 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
|
467 } |
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
|
468 #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
|
469 |
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
|
470 |
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
|
471 #ifdef ALT_BITSTREAM_WRITER |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
472 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
|
473 { |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
474 # ifdef ALIGNED_BITSTREAM_WRITER |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
475 # if defined(ARCH_X86) || defined(ARCH_X86_64) |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
476 asm volatile( |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
477 "movl %0, %%ecx \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
478 "xorl %%eax, %%eax \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
479 "shrdl %%cl, %1, %%eax \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
480 "shrl %%cl, %1 \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
481 "movl %0, %%ecx \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
482 "shrl $3, %%ecx \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
483 "andl $0xFFFFFFFC, %%ecx \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
484 "bswapl %1 \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
485 "orl %1, (%2, %%ecx) \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
486 "bswapl %%eax \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
487 "addl %3, %0 \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
488 "movl %%eax, 4(%2, %%ecx) \n\t" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
489 : "=&r" (s->index), "=&r" (value) |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
490 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n)) |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
491 : "%eax", "%ecx" |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
492 ); |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
493 # else |
235
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
494 int index= s->index; |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
495 uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5); |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
496 |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
497 value<<= 32-n; |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
498 |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
499 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
|
500 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
|
501 //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
|
502 index+= n; |
41f0ef2cd942
aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents:
234
diff
changeset
|
503 s->index= index; |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
504 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
505 # else //ALIGNED_BITSTREAM_WRITER |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
506 # if defined(ARCH_X86) || defined(ARCH_X86_64) |
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
|
507 asm volatile( |
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
|
508 "movl $7, %%ecx \n\t" |
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
|
509 "andl %0, %%ecx \n\t" |
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
|
510 "addl %3, %%ecx \n\t" |
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
|
511 "negl %%ecx \n\t" |
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
|
512 "shll %%cl, %1 \n\t" |
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
|
513 "bswapl %1 \n\t" |
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
|
514 "movl %0, %%ecx \n\t" |
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
|
515 "shrl $3, %%ecx \n\t" |
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
|
516 "orl %1, (%%ecx, %2) \n\t" |
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
|
517 "addl %3, %0 \n\t" |
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
|
518 "movl $0, 4(%%ecx, %2) \n\t" |
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
|
519 : "=&r" (s->index), "=&r" (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
|
520 : "r" (s->buf), "r" (n), "0" (s->index), "1" (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
|
521 : "%ecx" |
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
|
522 ); |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
523 # 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
|
524 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
|
525 uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3)); |
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
|
526 |
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
|
527 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
|
528 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
|
529 //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
|
530 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
|
531 s->index= index; |
708
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
532 # endif |
1aa1cbb8c3c1
indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents:
706
diff
changeset
|
533 # 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
|
534 } |
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
|
535 #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
|
536 |
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
|
537 |
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
|
538 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
|
539 { |
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
|
540 #ifdef ALT_BITSTREAM_WRITER |
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
|
541 return s->buf + (s->index>>3); |
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
|
542 #else |
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
|
543 return s->buf_ptr; |
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
|
544 #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
|
545 } |
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
|
546 |
1799 | 547 /** |
548 * | |
549 * PutBitContext must be flushed & aligned to a byte boundary before calling this. | |
550 */ | |
551 static inline void skip_put_bytes(PutBitContext *s, int n){ | |
552 assert((put_bits_count(s)&7)==0); | |
553 #ifdef ALT_BITSTREAM_WRITER | |
554 FIXME may need some cleaning of the buffer | |
555 s->index += n<<3; | |
556 #else | |
557 assert(s->bit_left==32); | |
558 s->buf_ptr += n; | |
559 #endif | |
560 } | |
561 | |
562 /** | |
563 * Changes the end of the buffer. | |
564 */ | |
565 static inline void set_put_bits_buffer_size(PutBitContext *s, int size){ | |
566 s->buf_end= s->buf + size; | |
567 } | |
568 | |
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
|
569 /* 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
|
570 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
|
571 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
|
572 |
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
|
573 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
|
574 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
|
575 |
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
|
576 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
|
577 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
|
578 |
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 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
|
580 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
|
581 |
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 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
|
583 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
|
584 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
|
585 |
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 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
|
587 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
|
588 |
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 SHOW_UBITS(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
|
590 will return the nest num 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
|
591 |
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 SHOW_SBITS(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
|
593 will return the nest num bits and do sign extension |
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 |
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 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
|
596 will skip over the next num 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
|
597 note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER |
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
|
598 |
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 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
|
600 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
|
601 |
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 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
|
603 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
|
604 |
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 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
|
606 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
|
607 |
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 LAST_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
|
609 is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER |
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
|
610 |
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
|
611 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
|
612 */ |
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
|
613 |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
614 static inline int unaligned32_be(const void *v) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
615 { |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
616 #ifdef CONFIG_ALIGN |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
617 const uint8_t *p=v; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
618 return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]); |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
619 #else |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
620 return be2me_32( unaligned32(v)); //original |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
621 #endif |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
622 } |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
623 |
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
|
624 #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
|
625 # 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
|
626 |
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
|
627 # 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
|
628 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
|
629 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
|
630 |
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
|
631 # 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
|
632 (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
|
633 |
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
|
634 # define UPDATE_CACHE(name, gb)\ |
2288 | 635 name##_cache= unaligned32_be( ((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
|
636 |
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
|
637 # 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
|
638 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
|
639 |
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
|
640 // 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
|
641 # 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
|
642 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
|
643 |
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
|
644 # 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
|
645 {\ |
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
|
646 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
|
647 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
|
648 }\ |
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
|
649 |
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
|
650 # 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
|
651 # 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
|
652 |
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
|
653 # define SHOW_UBITS(name, gb, num)\ |
525 | 654 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
|
655 |
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 # define SHOW_SBITS(name, gb, num)\ |
525 | 657 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
|
658 |
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 # 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
|
660 ((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
|
661 |
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 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
|
663 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
|
664 } |
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
|
665 #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
|
666 //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
|
667 |
1263
9fce515e9894
libmpeg2 style bitstream reader 17 vs 16 bit bugfix
michaelni
parents:
1261
diff
changeset
|
668 # 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
|
669 |
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 # 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
|
671 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
|
672 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
|
673 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
|
674 |
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 # 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
|
676 (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
|
677 (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
|
678 (gb)->buffer_ptr= name##_buffer_ptr;\ |
0 | 679 |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
680 #ifdef LIBMPEG2_BITSTREAM_READER_HACK |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
681 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
682 # define UPDATE_CACHE(name, gb)\ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
683 if(name##_bit_count >= 0){\ |
1257 | 684 name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\ |
685 ((uint16_t*)name##_buffer_ptr)++;\ | |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
686 name##_bit_count-= 16;\ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
687 }\ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
688 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
689 #else |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
690 |
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
|
691 # define UPDATE_CACHE(name, gb)\ |
1263
9fce515e9894
libmpeg2 style bitstream reader 17 vs 16 bit bugfix
michaelni
parents:
1261
diff
changeset
|
692 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
|
693 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
|
694 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
|
695 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
|
696 }\ |
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
|
697 |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
698 #endif |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
699 |
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
|
700 # 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
|
701 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
|
702 |
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
|
703 # 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
|
704 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
|
705 |
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 # 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
|
707 {\ |
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
|
708 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
|
709 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
|
710 }\ |
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 |
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
|
712 # 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
|
713 # 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
|
714 |
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
|
715 # define SHOW_UBITS(name, gb, num)\ |
525 | 716 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
|
717 |
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
|
718 # define SHOW_SBITS(name, gb, num)\ |
525 | 719 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
|
720 |
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
|
721 # 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
|
722 ((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
|
723 |
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
|
724 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
|
725 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
|
726 } |
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
|
727 |
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
|
728 #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
|
729 |
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
|
730 # 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
|
731 |
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
|
732 # 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
|
733 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
|
734 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
|
735 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
|
736 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
|
737 |
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
|
738 # 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
|
739 (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
|
740 (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
|
741 (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
|
742 (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
|
743 |
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
|
744 # 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
|
745 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
|
746 const uint32_t next= be2me_32( *name##_buffer_ptr );\ |
525 | 747 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
|
748 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
|
749 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
|
750 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
|
751 }\ |
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
|
752 |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
753 #if defined(ARCH_X86) || defined(ARCH_X86_64) |
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
|
754 # 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
|
755 asm(\ |
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
|
756 "shldl %2, %1, %0 \n\t"\ |
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
|
757 "shll %2, %1 \n\t"\ |
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
|
758 : "+r" (name##_cache0), "+r" (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
|
759 : "Ic" ((uint8_t)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
|
760 ); |
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
|
761 #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
|
762 # 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
|
763 name##_cache0 <<= (num);\ |
525 | 764 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
|
765 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
|
766 #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
|
767 |
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
|
768 # 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
|
769 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
|
770 |
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
|
771 # 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
|
772 {\ |
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
|
773 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
|
774 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
|
775 }\ |
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
|
776 |
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
|
777 # 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
|
778 # 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
|
779 |
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
|
780 # define SHOW_UBITS(name, gb, num)\ |
525 | 781 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
|
782 |
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
|
783 # define SHOW_SBITS(name, gb, num)\ |
525 | 784 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
|
785 |
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
|
786 # 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
|
787 (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
|
788 |
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
|
789 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
|
790 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
|
791 } |
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
|
792 |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
793 #endif |
20
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
794 |
1257 | 795 /** |
796 * read mpeg1 dc style vlc (sign bit + mantisse with no MSB). | |
797 * if MSB not set it is negative | |
798 * @param n length in bits | |
799 * @author BERO | |
800 */ | |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
801 static inline int get_xbits(GetBitContext *s, int n){ |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
802 register int tmp; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
803 register int32_t cache; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
804 OPEN_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
805 UPDATE_CACHE(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
806 cache = GET_CACHE(re,s); |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
807 if ((int32_t)cache<0) { //MSB=1 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
808 tmp = NEG_USR32(cache,n); |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
809 } else { |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
810 // tmp = (-1<<n) | NEG_USR32(cache,n) + 1; mpeg12.c algo |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
811 // tmp = - (NEG_USR32(cache,n) ^ ((1 << n) - 1)); h263.c algo |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
812 tmp = - NEG_USR32(~cache,n); |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
813 } |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
814 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
|
815 CLOSE_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
816 return tmp; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
817 } |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
818 |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
819 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
|
820 register int tmp; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
821 OPEN_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
822 UPDATE_CACHE(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
823 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
|
824 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
|
825 CLOSE_READER(re, s) |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
826 return tmp; |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
827 } |
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1226
diff
changeset
|
828 |
1257 | 829 /** |
830 * reads 0-17 bits. | |
831 * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant | |
832 */ | |
20
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
833 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
|
834 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
|
835 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
|
836 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
|
837 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
|
838 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
|
839 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
|
840 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
|
841 } |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
842 |
1257 | 843 unsigned int get_bits_long(GetBitContext *s, int n); |
844 | |
845 /** | |
846 * shows 0-17 bits. | |
847 * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant | |
848 */ | |
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
|
849 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
|
850 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
|
851 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
|
852 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
|
853 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
|
854 // 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
|
855 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
|
856 } |
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
|
857 |
1257 | 858 unsigned int show_bits_long(GetBitContext *s, int n); |
859 | |
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
|
860 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
|
861 //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
|
862 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
|
863 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
|
864 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
|
865 CLOSE_READER(re, s) |
20
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
866 } |
907b67420d84
inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents:
10
diff
changeset
|
867 |
21 | 868 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
|
869 #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
|
870 int index= s->index; |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
871 uint8_t result= s->buffer[ index>>3 ]; |
199
0f1dba8fc617
(commited by michael / arpi was crazy enough to give me his password)
arpi_esp
parents:
193
diff
changeset
|
872 result<<= (index&0x07); |
0f1dba8fc617
(commited by michael / arpi was crazy enough to give me his password)
arpi_esp
parents:
193
diff
changeset
|
873 result>>= 8 - 1; |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
874 index++; |
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
875 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
|
876 |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
877 return result; |
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
151
diff
changeset
|
878 #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
|
879 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
|
880 #endif |
21 | 881 } |
882 | |
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
|
883 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
|
884 return show_bits(s, 1); |
21 | 885 } |
886 | |
887 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
|
888 skip_bits(s, 1); |
21 | 889 } |
890 | |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
891 /** |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
892 * init GetBitContext. |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
893 * @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
|
894 * 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
|
895 * @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
|
896 */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
897 static inline void init_get_bits(GetBitContext *s, |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
898 const uint8_t *buffer, int bit_size) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
899 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
900 const int buffer_size= (bit_size+7)>>3; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
901 |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
902 s->buffer= buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
903 s->size_in_bits= bit_size; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
904 s->buffer_end= buffer + buffer_size; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
905 #ifdef ALT_BITSTREAM_READER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
906 s->index=0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
907 #elif defined LIBMPEG2_BITSTREAM_READER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
908 #ifdef LIBMPEG2_BITSTREAM_READER_HACK |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
909 if ((int)buffer&1) { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
910 /* word alignment */ |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
911 s->cache = (*buffer++)<<24; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
912 s->buffer_ptr = buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
913 s->bit_count = 16-8; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
914 } else |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
915 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
916 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
917 s->buffer_ptr = buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
918 s->bit_count = 16; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
919 s->cache = 0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
920 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
921 #elif defined A32_BITSTREAM_READER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
922 s->buffer_ptr = (uint32_t*)buffer; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
923 s->bit_count = 32; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
924 s->cache0 = 0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
925 s->cache1 = 0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
926 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
927 { |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
928 OPEN_READER(re, s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
929 UPDATE_CACHE(re, s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
930 UPDATE_CACHE(re, s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
931 CLOSE_READER(re, s) |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
932 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
933 #ifdef A32_BITSTREAM_READER |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
934 s->cache1 = 0; |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
935 #endif |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
936 } |
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1845
diff
changeset
|
937 |
862 | 938 int check_marker(GetBitContext *s, const char *msg); |
0 | 939 void align_get_bits(GetBitContext *s); |
940 int init_vlc(VLC *vlc, int nb_bits, int nb_codes, | |
941 const void *bits, int bits_wrap, int bits_size, | |
942 const void *codes, int codes_wrap, int codes_size); | |
943 void free_vlc(VLC *vlc); | |
944 | |
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
|
945 /** |
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
|
946 * |
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
|
947 * 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
|
948 * 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
|
949 * 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
|
950 */ |
529 | 951 #define GET_VLC(code, name, gb, table, bits, max_depth)\ |
952 {\ | |
953 int n, index, nb_bits;\ | |
954 \ | |
955 index= SHOW_UBITS(name, gb, bits);\ | |
956 code = table[index][0];\ | |
957 n = table[index][1];\ | |
958 \ | |
959 if(max_depth > 1 && n < 0){\ | |
960 LAST_SKIP_BITS(name, gb, bits)\ | |
961 UPDATE_CACHE(name, gb)\ | |
962 \ | |
963 nb_bits = -n;\ | |
964 \ | |
535 | 965 index= SHOW_UBITS(name, gb, nb_bits) + code;\ |
529 | 966 code = table[index][0];\ |
967 n = table[index][1];\ | |
968 if(max_depth > 2 && n < 0){\ | |
969 LAST_SKIP_BITS(name, gb, nb_bits)\ | |
970 UPDATE_CACHE(name, gb)\ | |
971 \ | |
972 nb_bits = -n;\ | |
973 \ | |
535 | 974 index= SHOW_UBITS(name, gb, nb_bits) + code;\ |
529 | 975 code = table[index][0];\ |
976 n = table[index][1];\ | |
977 }\ | |
978 }\ | |
979 SKIP_BITS(name, gb, n)\ | |
980 } | |
981 | |
542 | 982 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth)\ |
983 {\ | |
984 int n, index, nb_bits;\ | |
985 \ | |
986 index= SHOW_UBITS(name, gb, bits);\ | |
987 level = table[index].level;\ | |
988 n = table[index].len;\ | |
989 \ | |
990 if(max_depth > 1 && n < 0){\ | |
991 LAST_SKIP_BITS(name, gb, bits)\ | |
992 UPDATE_CACHE(name, gb)\ | |
993 \ | |
994 nb_bits = -n;\ | |
995 \ | |
996 index= SHOW_UBITS(name, gb, nb_bits) + level;\ | |
997 level = table[index].level;\ | |
998 n = table[index].len;\ | |
999 }\ | |
1000 run= table[index].run;\ | |
1001 SKIP_BITS(name, gb, n)\ | |
1002 } | |
1003 | |
531 | 1004 // deprecated, dont use get_vlc for new code, use get_vlc2 instead or use GET_VLC directly |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
1005 static inline int get_vlc(GetBitContext *s, VLC *vlc) |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
1006 { |
529 | 1007 int code; |
1008 VLC_TYPE (*table)[2]= vlc->table; | |
1009 | |
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
|
1010 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
|
1011 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
|
1012 |
529 | 1013 GET_VLC(code, re, s, table, vlc->bits, 3) |
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
|
1014 |
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
|
1015 CLOSE_READER(re, s) |
193
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
1016 return code; |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
1017 } |
b691dd3e9088
aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents:
192
diff
changeset
|
1018 |
1079 | 1019 /** |
1020 * parses a vlc code, faster then get_vlc() | |
1021 * @param bits is the number of bits which will be read at once, must be | |
1022 * identical to nb_bits in init_vlc() | |
1023 * @param max_depth is the number of times bits bits must be readed to completly | |
1024 * read the longest vlc code | |
1025 * = (max_vlc_length + bits - 1) / bits | |
1026 */ | |
550 | 1027 static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2], |
1028 int bits, int max_depth) | |
531 | 1029 { |
1030 int code; | |
1031 | |
1032 OPEN_READER(re, s) | |
1033 UPDATE_CACHE(re, s) | |
1034 | |
1035 GET_VLC(code, re, s, table, bits, max_depth) | |
1036 | |
1037 CLOSE_READER(re, s) | |
1038 return code; | |
1039 } | |
1040 | |
1147 | 1041 //#define TRACE |
1042 | |
1043 #ifdef TRACE | |
1044 | |
1045 static inline void print_bin(int bits, int n){ | |
1046 int i; | |
1047 | |
1048 for(i=n-1; i>=0; i--){ | |
1049 printf("%d", (bits>>i)&1); | |
1050 } | |
1051 for(i=n; i<24; i++) | |
1052 printf(" "); | |
1053 } | |
1054 | |
1055 static inline int get_bits_trace(GetBitContext *s, int n, char *file, char *func, int line){ | |
1056 int r= get_bits(s, n); | |
1057 | |
1058 print_bin(r, n); | |
1059 printf("%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line); | |
1060 return r; | |
1061 } | |
1062 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, char *func, int line){ | |
1063 int show= show_bits(s, 24); | |
1064 int pos= get_bits_count(s); | |
1065 int r= get_vlc2(s, table, bits, max_depth); | |
1066 int len= get_bits_count(s) - pos; | |
1067 int bits2= show>>(24-len); | |
1068 | |
1069 print_bin(bits2, len); | |
1070 | |
1071 printf("%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line); | |
1072 return r; | |
1073 } | |
1273 | 1074 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, char *func, int line){ |
1075 int show= show_bits(s, n); | |
1076 int r= get_xbits(s, n); | |
1077 | |
1078 print_bin(show, n); | |
1079 printf("%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line); | |
1080 return r; | |
1081 } | |
1147 | 1082 |
1083 #define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
1084 #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
1273 | 1085 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) |
1152 | 1086 #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__) |
1147 | 1087 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__) |
1088 | |
1940 | 1089 #define tprintf(...) av_log(NULL, AV_LOG_DEBUG, __VA_ARGS__) |
1170 | 1090 |
1091 #else //TRACE | |
1824 | 1092 #define tprintf(...) {} |
1170 | 1093 #endif |
542 | 1094 |
0 | 1095 /* define it to include statistics code (useful only for optimizing |
1096 codec efficiency */ | |
1097 //#define STATS | |
1098 | |
1099 #ifdef STATS | |
1100 | |
1101 enum { | |
1102 ST_UNKNOWN, | |
1103 ST_DC, | |
1104 ST_INTRA_AC, | |
1105 ST_INTER_AC, | |
1106 ST_INTRA_MB, | |
1107 ST_INTER_MB, | |
1108 ST_MV, | |
1109 ST_NB, | |
1110 }; | |
1111 | |
1112 extern int st_current_index; | |
1113 extern unsigned int st_bit_counts[ST_NB]; | |
1114 extern unsigned int st_out_bit_counts[ST_NB]; | |
1115 | |
1116 void print_stats(void); | |
1117 #endif | |
1118 | |
1119 /* misc math functions */ | |
1037 | 1120 extern const uint8_t ff_log2_tab[256]; |
0 | 1121 |
151
ae0516eadae2
fixed gcc-3.0.x compilation (by Michael Niedermayer)
nickols_k
parents:
144
diff
changeset
|
1122 static inline int av_log2(unsigned int v) |
0 | 1123 { |
1124 int n; | |
1125 | |
1126 n = 0; | |
1127 if (v & 0xffff0000) { | |
1128 v >>= 16; | |
1129 n += 16; | |
1130 } | |
1131 if (v & 0xff00) { | |
1132 v >>= 8; | |
1133 n += 8; | |
1134 } | |
1037 | 1135 n += ff_log2_tab[v]; |
1136 | |
0 | 1137 return n; |
1138 } | |
1139 | |
1037 | 1140 static inline int av_log2_16bit(unsigned int v) |
1141 { | |
1142 int n; | |
1143 | |
1144 n = 0; | |
1145 if (v & 0xff00) { | |
1146 v >>= 8; | |
1147 n += 8; | |
1148 } | |
1149 n += ff_log2_tab[v]; | |
1150 | |
1151 return n; | |
1152 } | |
1153 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
264
diff
changeset
|
1154 /* median of 3 */ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
264
diff
changeset
|
1155 static inline int mid_pred(int a, int b, int c) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
264
diff
changeset
|
1156 { |
1756 | 1157 #if 0 |
1158 int t= (a-b)&((a-b)>>31); | |
1159 a-=t; | |
1160 b+=t; | |
1161 b-= (b-c)&((b-c)>>31); | |
1162 b+= (a-b)&((a-b)>>31); | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
264
diff
changeset
|
1163 |
1756 | 1164 return b; |
1165 #else | |
1166 if(a>b){ | |
1167 if(c>b){ | |
1168 if(c>a) b=a; | |
1169 else b=c; | |
1170 } | |
1171 }else{ | |
1172 if(b>c){ | |
1173 if(c>a) b=c; | |
1174 else b=a; | |
1175 } | |
1176 } | |
1177 return b; | |
1178 #endif | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
264
diff
changeset
|
1179 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
264
diff
changeset
|
1180 |
327 | 1181 static inline int clip(int a, int amin, int amax) |
1182 { | |
1183 if (a < amin) | |
1184 return amin; | |
1185 else if (a > amax) | |
1186 return amax; | |
1187 else | |
1188 return a; | |
1189 } | |
1190 | |
1898 | 1191 static inline int clip_uint8(int a) |
1192 { | |
1193 if (a&(~255)) return (-a)>>31; | |
1194 else return a; | |
1195 } | |
1196 | |
324 | 1197 /* math */ |
1037 | 1198 extern const uint8_t ff_sqrt_tab[128]; |
609 | 1199 |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1124
diff
changeset
|
1200 int64_t ff_gcd(int64_t a, int64_t b); |
324 | 1201 |
451 | 1202 static inline int ff_sqrt(int a) |
1203 { | |
1204 int ret=0; | |
1205 int s; | |
1206 int ret_sq=0; | |
609 | 1207 |
1208 if(a<128) return ff_sqrt_tab[a]; | |
1209 | |
451 | 1210 for(s=15; s>=0; s--){ |
1211 int b= ret_sq + (1<<(s*2)) + (ret<<s)*2; | |
1212 if(b<=a){ | |
1213 ret_sq=b; | |
1214 ret+= 1<<s; | |
1215 } | |
1216 } | |
1217 return ret; | |
1218 } | |
701 | 1219 |
1220 /** | |
1221 * converts fourcc string to int | |
1222 */ | |
865 | 1223 static inline int ff_get_fourcc(const char *s){ |
701 | 1224 assert( strlen(s)==4 ); |
1401 | 1225 |
701 | 1226 return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24); |
1227 } | |
1228 | |
1139
6842feb093c1
rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)
michaelni
parents:
1130
diff
changeset
|
1229 #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24)) |
6842feb093c1
rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)
michaelni
parents:
1130
diff
changeset
|
1230 #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24)) |
6842feb093c1
rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)
michaelni
parents:
1130
diff
changeset
|
1231 |
6842feb093c1
rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)
michaelni
parents:
1130
diff
changeset
|
1232 |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
1233 #if defined(ARCH_X86) || defined(ARCH_X86_64) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1234 #define MASK_ABS(mask, level)\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1235 asm volatile(\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1236 "cdq \n\t"\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1237 "xorl %1, %0 \n\t"\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1238 "subl %1, %0 \n\t"\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1239 : "+a" (level), "=&d" (mask)\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1240 ); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1241 #else |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1242 #define MASK_ABS(mask, level)\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1243 mask= level>>31;\ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1244 level= (level^mask)-mask; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1245 #endif |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1246 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
701
diff
changeset
|
1247 |
451 | 1248 #if __CPU__ >= 686 && !defined(RUNTIME_CPUDETECT) |
1249 #define COPY3_IF_LT(x,y,a,b,c,d)\ | |
1250 asm volatile (\ | |
1251 "cmpl %0, %3 \n\t"\ | |
1252 "cmovl %3, %0 \n\t"\ | |
1253 "cmovl %4, %1 \n\t"\ | |
1254 "cmovl %5, %2 \n\t"\ | |
1255 : "+r" (x), "+r" (a), "+r" (c)\ | |
1256 : "r" (y), "r" (b), "r" (d)\ | |
1257 ); | |
1258 #else | |
1259 #define COPY3_IF_LT(x,y,a,b,c,d)\ | |
1260 if((y)<(x)){\ | |
1261 (x)=(y);\ | |
1262 (a)=(b);\ | |
1263 (c)=(d);\ | |
1264 } | |
1265 #endif | |
1266 | |
2293
15cfba1b97b5
adapting existing mmx/mmx2/sse/3dnow optimizations so they work on x86_64 patch by (Aurelien Jacobs <aurel at gnuage dot org>)
michael
parents:
2288
diff
changeset
|
1267 #if defined(ARCH_X86) || defined(ARCH_X86_64) |
2288 | 1268 static inline long long rdtsc(void) |
1281 | 1269 { |
1270 long long l; | |
1271 asm volatile( "rdtsc\n\t" | |
1272 : "=A" (l) | |
1273 ); | |
1274 return l; | |
1275 } | |
1276 | |
1277 #define START_TIMER \ | |
1278 uint64_t tend;\ | |
1279 uint64_t tstart= rdtsc();\ | |
1280 | |
1281 #define STOP_TIMER(id) \ | |
1282 tend= rdtsc();\ | |
1823
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1283 {\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1284 static uint64_t tsum=0;\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1285 static int tcount=0;\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1286 static int tskip_count=0;\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1287 if(tcount<2 || tend - tstart < 8*tsum/tcount){\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1288 tsum+= tend - tstart;\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1289 tcount++;\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1290 }else\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1291 tskip_count++;\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1292 if(256*256*256*64%(tcount+tskip_count)==0){\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1293 av_log(NULL, AV_LOG_DEBUG, "%Ld dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\ |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1294 }\ |
1281 | 1295 } |
2140 | 1296 #else |
1297 #define START_TIMER | |
1298 #define STOP_TIMER(id) {} | |
1281 | 1299 #endif |
1300 | |
370
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
359
diff
changeset
|
1301 #define CLAMP_TO_8BIT(d) ((d > 0xff) ? 0xff : (d < 0) ? 0 : d) |
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
359
diff
changeset
|
1302 |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1025
diff
changeset
|
1303 /* avoid usage of various functions */ |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1025
diff
changeset
|
1304 #define malloc please_use_av_malloc |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1025
diff
changeset
|
1305 #define free please_use_av_free |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1025
diff
changeset
|
1306 #define realloc please_use_av_realloc |
1921 | 1307 #define time time_is_forbidden_due_to_security_issues |
1308 #define rand rand_is_forbidden_due_to_state_trashing | |
1309 #define srand srand_is_forbidden_due_to_state_trashing | |
1823
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1310 #if !(defined(LIBAVFORMAT_BUILD) || defined(_FRAMEHOOK_H)) |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1311 #define printf please_use_av_log |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1312 #define fprintf please_use_av_log |
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
1313 #endif |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
1025
diff
changeset
|
1314 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1315 #define CHECKED_ALLOCZ(p, size)\ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1316 {\ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1317 p= av_mallocz(size);\ |
1332 | 1318 if(p==NULL && (size)!=0){\ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1319 perror("malloc");\ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1320 goto fail;\ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1321 }\ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1322 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1171
diff
changeset
|
1323 |
488 | 1324 #endif /* HAVE_AV_CONFIG_H */ |
1325 | |
1326 #endif /* COMMON_H */ |