diff options
author | Mohamed Tarek <mt@rockbox.org> | 2010-07-17 07:46:38 +0000 |
---|---|---|
committer | Mohamed Tarek <mt@rockbox.org> | 2010-07-17 07:46:38 +0000 |
commit | 090768194fdbd611b995572f424c6fae690eb329 (patch) | |
tree | 13ec87dee0870933c255490e4e93c3d7feadaf02 /apps | |
parent | 4a4699692270906976a9bc99d4c11f625fd756c6 (diff) | |
download | rockbox-090768194fdbd611b995572f424c6fae690eb329.tar.gz rockbox-090768194fdbd611b995572f424c6fae690eb329.zip |
Enable ff_copy_bits in ffmpeg_bitstream.c and put_bits.h and intreadwrite.h to codeclib.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@27452 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps')
-rw-r--r-- | apps/codecs/lib/ffmpeg_bitstream.c | 8 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_get_bits.h | 11 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_intreadwrite.h | 484 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_put_bits.h | 323 |
4 files changed, 813 insertions, 13 deletions
diff --git a/apps/codecs/lib/ffmpeg_bitstream.c b/apps/codecs/lib/ffmpeg_bitstream.c index be0a3a11f6..542f2671e5 100644 --- a/apps/codecs/lib/ffmpeg_bitstream.c +++ b/apps/codecs/lib/ffmpeg_bitstream.c | |||
@@ -30,7 +30,8 @@ | |||
30 | 30 | ||
31 | //#include "avcodec.h" | 31 | //#include "avcodec.h" |
32 | #include "ffmpeg_get_bits.h" | 32 | #include "ffmpeg_get_bits.h" |
33 | //#include "put_bits.h" | 33 | #include "ffmpeg_put_bits.h" |
34 | #include "ffmpeg_intreadwrite.h" | ||
34 | 35 | ||
35 | #define av_log(...) | 36 | #define av_log(...) |
36 | 37 | ||
@@ -65,6 +66,7 @@ void ff_put_string(PutBitContext *pb, const char *string, int terminate_string) | |||
65 | if(terminate_string) | 66 | if(terminate_string) |
66 | put_bits(pb, 8, 0); | 67 | put_bits(pb, 8, 0); |
67 | } | 68 | } |
69 | #endif | ||
68 | 70 | ||
69 | void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length) | 71 | void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length) |
70 | { | 72 | { |
@@ -74,7 +76,7 @@ void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length) | |||
74 | 76 | ||
75 | if(length==0) return; | 77 | if(length==0) return; |
76 | 78 | ||
77 | if(CONFIG_SMALL || words < 16 || put_bits_count(pb)&7){ | 79 | if(words < 16 || put_bits_count(pb)&7){ |
78 | for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i)); | 80 | for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i)); |
79 | }else{ | 81 | }else{ |
80 | for(i=0; put_bits_count(pb)&31; i++) | 82 | for(i=0; put_bits_count(pb)&31; i++) |
@@ -86,7 +88,7 @@ void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length) | |||
86 | 88 | ||
87 | put_bits(pb, bits, AV_RB16(src + 2*words)>>(16-bits)); | 89 | put_bits(pb, bits, AV_RB16(src + 2*words)>>(16-bits)); |
88 | } | 90 | } |
89 | #endif | 91 | |
90 | /* VLC decoding */ | 92 | /* VLC decoding */ |
91 | 93 | ||
92 | //#define DEBUG_VLC | 94 | //#define DEBUG_VLC |
diff --git a/apps/codecs/lib/ffmpeg_get_bits.h b/apps/codecs/lib/ffmpeg_get_bits.h index 1a461e9e25..8fce395a4d 100644 --- a/apps/codecs/lib/ffmpeg_get_bits.h +++ b/apps/codecs/lib/ffmpeg_get_bits.h | |||
@@ -28,6 +28,7 @@ | |||
28 | 28 | ||
29 | #include <stdint.h> | 29 | #include <stdint.h> |
30 | #include <stdlib.h> | 30 | #include <stdlib.h> |
31 | #include "ffmpeg_intreadwrite.h" | ||
31 | //#include <assert.h> | 32 | //#include <assert.h> |
32 | //#include "libavutil/bswap.h" | 33 | //#include "libavutil/bswap.h" |
33 | //#include "libavutil/common.h" | 34 | //#include "libavutil/common.h" |
@@ -56,16 +57,6 @@ | |||
56 | #define av_const __attribute__((const)) | 57 | #define av_const __attribute__((const)) |
57 | #define av_always_inline inline __attribute__((always_inline)) | 58 | #define av_always_inline inline __attribute__((always_inline)) |
58 | 59 | ||
59 | /* Coldfire cpu's support unaligned long reads */ | ||
60 | #ifdef CPU_COLDFIRE | ||
61 | #define AV_RB32(x) (*(const uint32_t*)(x)) | ||
62 | #else | ||
63 | /* The following define is taken from libavutil/intreadwrite.h */ | ||
64 | #define AV_RB32(x) ((((const uint8_t*)(x))[0] << 24) | \ | ||
65 | (((const uint8_t*)(x))[1] << 16) | \ | ||
66 | (((const uint8_t*)(x))[2] << 8) | \ | ||
67 | ((const uint8_t*)(x))[3]) | ||
68 | #endif | ||
69 | /* The following is taken from mathops.h */ | 60 | /* The following is taken from mathops.h */ |
70 | 61 | ||
71 | #ifndef sign_extend | 62 | #ifndef sign_extend |
diff --git a/apps/codecs/lib/ffmpeg_intreadwrite.h b/apps/codecs/lib/ffmpeg_intreadwrite.h new file mode 100644 index 0000000000..ca718106d1 --- /dev/null +++ b/apps/codecs/lib/ffmpeg_intreadwrite.h | |||
@@ -0,0 +1,484 @@ | |||
1 | /* | ||
2 | * This file is part of FFmpeg. | ||
3 | * | ||
4 | * FFmpeg is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU Lesser General Public | ||
6 | * License as published by the Free Software Foundation; either | ||
7 | * version 2.1 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * FFmpeg is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Lesser General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Lesser General Public | ||
15 | * License along with FFmpeg; if not, write to the Free Software | ||
16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
17 | */ | ||
18 | |||
19 | #ifndef AVUTIL_INTREADWRITE_H | ||
20 | #define AVUTIL_INTREADWRITE_H | ||
21 | |||
22 | #include <stdint.h> | ||
23 | /* | ||
24 | * Arch-specific headers can provide any combination of | ||
25 | * AV_[RW][BLN](16|24|32|64) and AV_(COPY|SWAP|ZERO)(64|128) macros. | ||
26 | * Preprocessor symbols must be defined, even if these are implemented | ||
27 | * as inline functions. | ||
28 | */ | ||
29 | |||
30 | /* | ||
31 | * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers. | ||
32 | */ | ||
33 | #define HAVE_BIGENDIAN 0 | ||
34 | #if HAVE_BIGENDIAN | ||
35 | |||
36 | # if defined(AV_RN16) && !defined(AV_RB16) | ||
37 | # define AV_RB16(p) AV_RN16(p) | ||
38 | # elif !defined(AV_RN16) && defined(AV_RB16) | ||
39 | # define AV_RN16(p) AV_RB16(p) | ||
40 | # endif | ||
41 | |||
42 | # if defined(AV_WN16) && !defined(AV_WB16) | ||
43 | # define AV_WB16(p, v) AV_WN16(p, v) | ||
44 | # elif !defined(AV_WN16) && defined(AV_WB16) | ||
45 | # define AV_WN16(p, v) AV_WB16(p, v) | ||
46 | # endif | ||
47 | |||
48 | # if defined(AV_RN24) && !defined(AV_RB24) | ||
49 | # define AV_RB24(p) AV_RN24(p) | ||
50 | # elif !defined(AV_RN24) && defined(AV_RB24) | ||
51 | # define AV_RN24(p) AV_RB24(p) | ||
52 | # endif | ||
53 | |||
54 | # if defined(AV_WN24) && !defined(AV_WB24) | ||
55 | # define AV_WB24(p, v) AV_WN24(p, v) | ||
56 | # elif !defined(AV_WN24) && defined(AV_WB24) | ||
57 | # define AV_WN24(p, v) AV_WB24(p, v) | ||
58 | # endif | ||
59 | |||
60 | # if defined(AV_RN32) && !defined(AV_RB32) | ||
61 | # define AV_RB32(p) AV_RN32(p) | ||
62 | # elif !defined(AV_RN32) && defined(AV_RB32) | ||
63 | # define AV_RN32(p) AV_RB32(p) | ||
64 | # endif | ||
65 | |||
66 | # if defined(AV_WN32) && !defined(AV_WB32) | ||
67 | # define AV_WB32(p, v) AV_WN32(p, v) | ||
68 | # elif !defined(AV_WN32) && defined(AV_WB32) | ||
69 | # define AV_WN32(p, v) AV_WB32(p, v) | ||
70 | # endif | ||
71 | |||
72 | # if defined(AV_RN64) && !defined(AV_RB64) | ||
73 | # define AV_RB64(p) AV_RN64(p) | ||
74 | # elif !defined(AV_RN64) && defined(AV_RB64) | ||
75 | # define AV_RN64(p) AV_RB64(p) | ||
76 | # endif | ||
77 | |||
78 | # if defined(AV_WN64) && !defined(AV_WB64) | ||
79 | # define AV_WB64(p, v) AV_WN64(p, v) | ||
80 | # elif !defined(AV_WN64) && defined(AV_WB64) | ||
81 | # define AV_WN64(p, v) AV_WB64(p, v) | ||
82 | # endif | ||
83 | |||
84 | #else /* HAVE_BIGENDIAN */ | ||
85 | |||
86 | # if defined(AV_RN16) && !defined(AV_RL16) | ||
87 | # define AV_RL16(p) AV_RN16(p) | ||
88 | # elif !defined(AV_RN16) && defined(AV_RL16) | ||
89 | # define AV_RN16(p) AV_RL16(p) | ||
90 | # endif | ||
91 | |||
92 | # if defined(AV_WN16) && !defined(AV_WL16) | ||
93 | # define AV_WL16(p, v) AV_WN16(p, v) | ||
94 | # elif !defined(AV_WN16) && defined(AV_WL16) | ||
95 | # define AV_WN16(p, v) AV_WL16(p, v) | ||
96 | # endif | ||
97 | |||
98 | # if defined(AV_RN24) && !defined(AV_RL24) | ||
99 | # define AV_RL24(p) AV_RN24(p) | ||
100 | # elif !defined(AV_RN24) && defined(AV_RL24) | ||
101 | # define AV_RN24(p) AV_RL24(p) | ||
102 | # endif | ||
103 | |||
104 | # if defined(AV_WN24) && !defined(AV_WL24) | ||
105 | # define AV_WL24(p, v) AV_WN24(p, v) | ||
106 | # elif !defined(AV_WN24) && defined(AV_WL24) | ||
107 | # define AV_WN24(p, v) AV_WL24(p, v) | ||
108 | # endif | ||
109 | |||
110 | # if defined(AV_RN32) && !defined(AV_RL32) | ||
111 | # define AV_RL32(p) AV_RN32(p) | ||
112 | # elif !defined(AV_RN32) && defined(AV_RL32) | ||
113 | # define AV_RN32(p) AV_RL32(p) | ||
114 | # endif | ||
115 | |||
116 | # if defined(AV_WN32) && !defined(AV_WL32) | ||
117 | # define AV_WL32(p, v) AV_WN32(p, v) | ||
118 | # elif !defined(AV_WN32) && defined(AV_WL32) | ||
119 | # define AV_WN32(p, v) AV_WL32(p, v) | ||
120 | # endif | ||
121 | |||
122 | # if defined(AV_RN64) && !defined(AV_RL64) | ||
123 | # define AV_RL64(p) AV_RN64(p) | ||
124 | # elif !defined(AV_RN64) && defined(AV_RL64) | ||
125 | # define AV_RN64(p) AV_RL64(p) | ||
126 | # endif | ||
127 | |||
128 | # if defined(AV_WN64) && !defined(AV_WL64) | ||
129 | # define AV_WL64(p, v) AV_WN64(p, v) | ||
130 | # elif !defined(AV_WN64) && defined(AV_WL64) | ||
131 | # define AV_WN64(p, v) AV_WL64(p, v) | ||
132 | # endif | ||
133 | |||
134 | #endif /* !HAVE_BIGENDIAN */ | ||
135 | |||
136 | #define HAVE_ATTRIBUTE_PACKED 0 | ||
137 | #define HAVE_FAST_UNALIGNED 0 | ||
138 | /* | ||
139 | * Define AV_[RW]N helper macros to simplify definitions not provided | ||
140 | * by per-arch headers. | ||
141 | */ | ||
142 | |||
143 | #if HAVE_ATTRIBUTE_PACKED | ||
144 | |||
145 | union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias; | ||
146 | union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias; | ||
147 | union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias; | ||
148 | |||
149 | # define AV_RN(s, p) (((const union unaligned_##s *) (p))->l) | ||
150 | # define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v)) | ||
151 | |||
152 | #elif defined(__DECC) | ||
153 | |||
154 | # define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) | ||
155 | # define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) | ||
156 | |||
157 | #elif HAVE_FAST_UNALIGNED | ||
158 | |||
159 | # define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) | ||
160 | # define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) | ||
161 | |||
162 | #else | ||
163 | |||
164 | #ifndef AV_RB16 | ||
165 | # define AV_RB16(x) \ | ||
166 | ((((const uint8_t*)(x))[0] << 8) | \ | ||
167 | ((const uint8_t*)(x))[1]) | ||
168 | #endif | ||
169 | #ifndef AV_WB16 | ||
170 | # define AV_WB16(p, d) do { \ | ||
171 | ((uint8_t*)(p))[1] = (d); \ | ||
172 | ((uint8_t*)(p))[0] = (d)>>8; \ | ||
173 | } while(0) | ||
174 | #endif | ||
175 | |||
176 | #ifndef AV_RL16 | ||
177 | # define AV_RL16(x) \ | ||
178 | ((((const uint8_t*)(x))[1] << 8) | \ | ||
179 | ((const uint8_t*)(x))[0]) | ||
180 | #endif | ||
181 | #ifndef AV_WL16 | ||
182 | # define AV_WL16(p, d) do { \ | ||
183 | ((uint8_t*)(p))[0] = (d); \ | ||
184 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
185 | } while(0) | ||
186 | #endif | ||
187 | |||
188 | #ifndef AV_RB32 | ||
189 | /* Coldfire cpu's support unaligned long reads */ | ||
190 | #ifdef CPU_COLDFIRE | ||
191 | #define AV_RB32(x) (*(const uint32_t*)(x)) | ||
192 | #else | ||
193 | # define AV_RB32(x) \ | ||
194 | ((((const uint8_t*)(x))[0] << 24) | \ | ||
195 | (((const uint8_t*)(x))[1] << 16) | \ | ||
196 | (((const uint8_t*)(x))[2] << 8) | \ | ||
197 | ((const uint8_t*)(x))[3]) | ||
198 | #endif | ||
199 | #endif | ||
200 | #ifndef AV_WB32 | ||
201 | # define AV_WB32(p, d) do { \ | ||
202 | ((uint8_t*)(p))[3] = (d); \ | ||
203 | ((uint8_t*)(p))[2] = (d)>>8; \ | ||
204 | ((uint8_t*)(p))[1] = (d)>>16; \ | ||
205 | ((uint8_t*)(p))[0] = (d)>>24; \ | ||
206 | } while(0) | ||
207 | #endif | ||
208 | |||
209 | #ifndef AV_RL32 | ||
210 | # define AV_RL32(x) \ | ||
211 | ((((const uint8_t*)(x))[3] << 24) | \ | ||
212 | (((const uint8_t*)(x))[2] << 16) | \ | ||
213 | (((const uint8_t*)(x))[1] << 8) | \ | ||
214 | ((const uint8_t*)(x))[0]) | ||
215 | #endif | ||
216 | #ifndef AV_WL32 | ||
217 | # define AV_WL32(p, d) do { \ | ||
218 | ((uint8_t*)(p))[0] = (d); \ | ||
219 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
220 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
221 | ((uint8_t*)(p))[3] = (d)>>24; \ | ||
222 | } while(0) | ||
223 | #endif | ||
224 | |||
225 | #ifndef AV_RB64 | ||
226 | # define AV_RB64(x) \ | ||
227 | (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ | ||
228 | ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ | ||
229 | ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ | ||
230 | ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ | ||
231 | ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ | ||
232 | ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ | ||
233 | ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ | ||
234 | (uint64_t)((const uint8_t*)(x))[7]) | ||
235 | #endif | ||
236 | #ifndef AV_WB64 | ||
237 | # define AV_WB64(p, d) do { \ | ||
238 | ((uint8_t*)(p))[7] = (d); \ | ||
239 | ((uint8_t*)(p))[6] = (d)>>8; \ | ||
240 | ((uint8_t*)(p))[5] = (d)>>16; \ | ||
241 | ((uint8_t*)(p))[4] = (d)>>24; \ | ||
242 | ((uint8_t*)(p))[3] = (d)>>32; \ | ||
243 | ((uint8_t*)(p))[2] = (d)>>40; \ | ||
244 | ((uint8_t*)(p))[1] = (d)>>48; \ | ||
245 | ((uint8_t*)(p))[0] = (d)>>56; \ | ||
246 | } while(0) | ||
247 | #endif | ||
248 | |||
249 | #ifndef AV_RL64 | ||
250 | # define AV_RL64(x) \ | ||
251 | (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ | ||
252 | ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ | ||
253 | ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ | ||
254 | ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ | ||
255 | ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ | ||
256 | ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ | ||
257 | ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ | ||
258 | (uint64_t)((const uint8_t*)(x))[0]) | ||
259 | #endif | ||
260 | #ifndef AV_WL64 | ||
261 | # define AV_WL64(p, d) do { \ | ||
262 | ((uint8_t*)(p))[0] = (d); \ | ||
263 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
264 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
265 | ((uint8_t*)(p))[3] = (d)>>24; \ | ||
266 | ((uint8_t*)(p))[4] = (d)>>32; \ | ||
267 | ((uint8_t*)(p))[5] = (d)>>40; \ | ||
268 | ((uint8_t*)(p))[6] = (d)>>48; \ | ||
269 | ((uint8_t*)(p))[7] = (d)>>56; \ | ||
270 | } while(0) | ||
271 | #endif | ||
272 | |||
273 | #if HAVE_BIGENDIAN | ||
274 | # define AV_RN(s, p) AV_RB##s(p) | ||
275 | # define AV_WN(s, p, v) AV_WB##s(p, v) | ||
276 | #else | ||
277 | # define AV_RN(s, p) AV_RL##s(p) | ||
278 | # define AV_WN(s, p, v) AV_WL##s(p, v) | ||
279 | #endif | ||
280 | |||
281 | #endif /* HAVE_FAST_UNALIGNED */ | ||
282 | |||
283 | #ifndef AV_RN16 | ||
284 | # define AV_RN16(p) AV_RN(16, p) | ||
285 | #endif | ||
286 | |||
287 | #ifndef AV_RN32 | ||
288 | # define AV_RN32(p) AV_RN(32, p) | ||
289 | #endif | ||
290 | |||
291 | #ifndef AV_RN64 | ||
292 | # define AV_RN64(p) AV_RN(64, p) | ||
293 | #endif | ||
294 | |||
295 | #ifndef AV_WN16 | ||
296 | # define AV_WN16(p, v) AV_WN(16, p, v) | ||
297 | #endif | ||
298 | |||
299 | #ifndef AV_WN32 | ||
300 | # define AV_WN32(p, v) AV_WN(32, p, v) | ||
301 | #endif | ||
302 | |||
303 | #ifndef AV_WN64 | ||
304 | # define AV_WN64(p, v) AV_WN(64, p, v) | ||
305 | #endif | ||
306 | |||
307 | #if HAVE_BIGENDIAN | ||
308 | # define AV_RB(s, p) AV_RN##s(p) | ||
309 | # define AV_WB(s, p, v) AV_WN##s(p, v) | ||
310 | # define AV_RL(s, p) bswap_##s(AV_RN##s(p)) | ||
311 | # define AV_WL(s, p, v) AV_WN##s(p, bswap_##s(v)) | ||
312 | #else | ||
313 | # define AV_RB(s, p) bswap_##s(AV_RN##s(p)) | ||
314 | # define AV_WB(s, p, v) AV_WN##s(p, bswap_##s(v)) | ||
315 | # define AV_RL(s, p) AV_RN##s(p) | ||
316 | # define AV_WL(s, p, v) AV_WN##s(p, v) | ||
317 | #endif | ||
318 | |||
319 | #define AV_RB8(x) (((const uint8_t*)(x))[0]) | ||
320 | #define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) | ||
321 | |||
322 | #define AV_RL8(x) AV_RB8(x) | ||
323 | #define AV_WL8(p, d) AV_WB8(p, d) | ||
324 | |||
325 | #ifndef AV_RB16 | ||
326 | # define AV_RB16(p) AV_RB(16, p) | ||
327 | #endif | ||
328 | #ifndef AV_WB16 | ||
329 | # define AV_WB16(p, v) AV_WB(16, p, v) | ||
330 | #endif | ||
331 | |||
332 | #ifndef AV_RL16 | ||
333 | # define AV_RL16(p) AV_RL(16, p) | ||
334 | #endif | ||
335 | #ifndef AV_WL16 | ||
336 | # define AV_WL16(p, v) AV_WL(16, p, v) | ||
337 | #endif | ||
338 | |||
339 | #ifndef AV_RB32 | ||
340 | # define AV_RB32(p) AV_RB(32, p) | ||
341 | #endif | ||
342 | #ifndef AV_WB32 | ||
343 | # define AV_WB32(p, v) AV_WB(32, p, v) | ||
344 | #endif | ||
345 | |||
346 | #ifndef AV_RL32 | ||
347 | # define AV_RL32(p) AV_RL(32, p) | ||
348 | #endif | ||
349 | #ifndef AV_WL32 | ||
350 | # define AV_WL32(p, v) AV_WL(32, p, v) | ||
351 | #endif | ||
352 | |||
353 | #ifndef AV_RB64 | ||
354 | # define AV_RB64(p) AV_RB(64, p) | ||
355 | #endif | ||
356 | #ifndef AV_WB64 | ||
357 | # define AV_WB64(p, v) AV_WB(64, p, v) | ||
358 | #endif | ||
359 | |||
360 | #ifndef AV_RL64 | ||
361 | # define AV_RL64(p) AV_RL(64, p) | ||
362 | #endif | ||
363 | #ifndef AV_WL64 | ||
364 | # define AV_WL64(p, v) AV_WL(64, p, v) | ||
365 | #endif | ||
366 | |||
367 | #ifndef AV_RB24 | ||
368 | # define AV_RB24(x) \ | ||
369 | ((((const uint8_t*)(x))[0] << 16) | \ | ||
370 | (((const uint8_t*)(x))[1] << 8) | \ | ||
371 | ((const uint8_t*)(x))[2]) | ||
372 | #endif | ||
373 | #ifndef AV_WB24 | ||
374 | # define AV_WB24(p, d) do { \ | ||
375 | ((uint8_t*)(p))[2] = (d); \ | ||
376 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
377 | ((uint8_t*)(p))[0] = (d)>>16; \ | ||
378 | } while(0) | ||
379 | #endif | ||
380 | |||
381 | #ifndef AV_RL24 | ||
382 | # define AV_RL24(x) \ | ||
383 | ((((const uint8_t*)(x))[2] << 16) | \ | ||
384 | (((const uint8_t*)(x))[1] << 8) | \ | ||
385 | ((const uint8_t*)(x))[0]) | ||
386 | #endif | ||
387 | #ifndef AV_WL24 | ||
388 | # define AV_WL24(p, d) do { \ | ||
389 | ((uint8_t*)(p))[0] = (d); \ | ||
390 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
391 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
392 | } while(0) | ||
393 | #endif | ||
394 | |||
395 | /* | ||
396 | * The AV_[RW]NA macros access naturally aligned data | ||
397 | * in a type-safe way. | ||
398 | */ | ||
399 | |||
400 | #define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s) | ||
401 | #define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v)) | ||
402 | |||
403 | #ifndef AV_RN16A | ||
404 | # define AV_RN16A(p) AV_RNA(16, p) | ||
405 | #endif | ||
406 | |||
407 | #ifndef AV_RN32A | ||
408 | # define AV_RN32A(p) AV_RNA(32, p) | ||
409 | #endif | ||
410 | |||
411 | #ifndef AV_RN64A | ||
412 | # define AV_RN64A(p) AV_RNA(64, p) | ||
413 | #endif | ||
414 | |||
415 | #ifndef AV_WN16A | ||
416 | # define AV_WN16A(p, v) AV_WNA(16, p, v) | ||
417 | #endif | ||
418 | |||
419 | #ifndef AV_WN32A | ||
420 | # define AV_WN32A(p, v) AV_WNA(32, p, v) | ||
421 | #endif | ||
422 | |||
423 | #ifndef AV_WN64A | ||
424 | # define AV_WN64A(p, v) AV_WNA(64, p, v) | ||
425 | #endif | ||
426 | |||
427 | /* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be | ||
428 | * naturally aligned. They may be implemented using MMX, | ||
429 | * so emms_c() must be called before using any float code | ||
430 | * afterwards. | ||
431 | */ | ||
432 | |||
433 | #define AV_COPY(n, d, s) \ | ||
434 | (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n) | ||
435 | |||
436 | #ifndef AV_COPY16 | ||
437 | # define AV_COPY16(d, s) AV_COPY(16, d, s) | ||
438 | #endif | ||
439 | |||
440 | #ifndef AV_COPY32 | ||
441 | # define AV_COPY32(d, s) AV_COPY(32, d, s) | ||
442 | #endif | ||
443 | |||
444 | #ifndef AV_COPY64 | ||
445 | # define AV_COPY64(d, s) AV_COPY(64, d, s) | ||
446 | #endif | ||
447 | |||
448 | #ifndef AV_COPY128 | ||
449 | # define AV_COPY128(d, s) \ | ||
450 | do { \ | ||
451 | AV_COPY64(d, s); \ | ||
452 | AV_COPY64((char*)(d)+8, (char*)(s)+8); \ | ||
453 | } while(0) | ||
454 | #endif | ||
455 | |||
456 | #define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b)) | ||
457 | |||
458 | #ifndef AV_SWAP64 | ||
459 | # define AV_SWAP64(a, b) AV_SWAP(64, a, b) | ||
460 | #endif | ||
461 | |||
462 | #define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0) | ||
463 | |||
464 | #ifndef AV_ZERO16 | ||
465 | # define AV_ZERO16(d) AV_ZERO(16, d) | ||
466 | #endif | ||
467 | |||
468 | #ifndef AV_ZERO32 | ||
469 | # define AV_ZERO32(d) AV_ZERO(32, d) | ||
470 | #endif | ||
471 | |||
472 | #ifndef AV_ZERO64 | ||
473 | # define AV_ZERO64(d) AV_ZERO(64, d) | ||
474 | #endif | ||
475 | |||
476 | #ifndef AV_ZERO128 | ||
477 | # define AV_ZERO128(d) \ | ||
478 | do { \ | ||
479 | AV_ZERO64(d); \ | ||
480 | AV_ZERO64((char*)(d)+8); \ | ||
481 | } while(0) | ||
482 | #endif | ||
483 | |||
484 | #endif /* AVUTIL_INTREADWRITE_H */ | ||
diff --git a/apps/codecs/lib/ffmpeg_put_bits.h b/apps/codecs/lib/ffmpeg_put_bits.h new file mode 100644 index 0000000000..38db55fe18 --- /dev/null +++ b/apps/codecs/lib/ffmpeg_put_bits.h | |||
@@ -0,0 +1,323 @@ | |||
1 | /* | ||
2 | * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file libavcodec/put_bits.h | ||
23 | * bitstream writer API | ||
24 | */ | ||
25 | |||
26 | #ifndef AVCODEC_PUT_BITS_H | ||
27 | #define AVCODEC_PUT_BITS_H | ||
28 | |||
29 | #include <stdint.h> | ||
30 | #include <stdlib.h> | ||
31 | #include "ffmpeg_bswap.h" | ||
32 | #include "ffmpeg_intreadwrite.h" | ||
33 | |||
34 | #define av_log(...) | ||
35 | #define HAVE_FAST_UNALIGNED 0 | ||
36 | |||
37 | /* buf and buf_end must be present and used by every alternative writer. */ | ||
38 | typedef struct PutBitContext { | ||
39 | #ifdef ALT_BITSTREAM_WRITER | ||
40 | uint8_t *buf, *buf_end; | ||
41 | int index; | ||
42 | #else | ||
43 | uint32_t bit_buf; | ||
44 | int bit_left; | ||
45 | uint8_t *buf, *buf_ptr, *buf_end; | ||
46 | #endif | ||
47 | int size_in_bits; | ||
48 | } PutBitContext; | ||
49 | |||
50 | /** | ||
51 | * Initializes the PutBitContext s. | ||
52 | * | ||
53 | * @param buffer the buffer where to put bits | ||
54 | * @param buffer_size the size in bytes of buffer | ||
55 | */ | ||
56 | static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size) | ||
57 | { | ||
58 | if(buffer_size < 0) { | ||
59 | buffer_size = 0; | ||
60 | buffer = NULL; | ||
61 | } | ||
62 | |||
63 | s->size_in_bits= 8*buffer_size; | ||
64 | s->buf = buffer; | ||
65 | s->buf_end = s->buf + buffer_size; | ||
66 | #ifdef ALT_BITSTREAM_WRITER | ||
67 | s->index=0; | ||
68 | ((uint32_t*)(s->buf))[0]=0; | ||
69 | // memset(buffer, 0, buffer_size); | ||
70 | #else | ||
71 | s->buf_ptr = s->buf; | ||
72 | s->bit_left=32; | ||
73 | s->bit_buf=0; | ||
74 | #endif | ||
75 | } | ||
76 | |||
77 | /** | ||
78 | * Returns the total number of bits written to the bitstream. | ||
79 | */ | ||
80 | static inline int put_bits_count(PutBitContext *s) | ||
81 | { | ||
82 | #ifdef ALT_BITSTREAM_WRITER | ||
83 | return s->index; | ||
84 | #else | ||
85 | return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left; | ||
86 | #endif | ||
87 | } | ||
88 | |||
89 | /** | ||
90 | * Pads the end of the output stream with zeros. | ||
91 | */ | ||
92 | static inline void flush_put_bits(PutBitContext *s) | ||
93 | { | ||
94 | #ifdef ALT_BITSTREAM_WRITER | ||
95 | align_put_bits(s); | ||
96 | #else | ||
97 | #ifndef BITSTREAM_WRITER_LE | ||
98 | s->bit_buf<<= s->bit_left; | ||
99 | #endif | ||
100 | while (s->bit_left < 32) { | ||
101 | /* XXX: should test end of buffer */ | ||
102 | #ifdef BITSTREAM_WRITER_LE | ||
103 | *s->buf_ptr++=s->bit_buf; | ||
104 | s->bit_buf>>=8; | ||
105 | #else | ||
106 | *s->buf_ptr++=s->bit_buf >> 24; | ||
107 | s->bit_buf<<=8; | ||
108 | #endif | ||
109 | s->bit_left+=8; | ||
110 | } | ||
111 | s->bit_left=32; | ||
112 | s->bit_buf=0; | ||
113 | #endif | ||
114 | } | ||
115 | |||
116 | #if defined(ALT_BITSTREAM_WRITER) || defined(BITSTREAM_WRITER_LE) | ||
117 | #define align_put_bits align_put_bits_unsupported_here | ||
118 | #define ff_put_string ff_put_string_unsupported_here | ||
119 | #define ff_copy_bits ff_copy_bits_unsupported_here | ||
120 | #else | ||
121 | /** | ||
122 | * Pads the bitstream with zeros up to the next byte boundary. | ||
123 | */ | ||
124 | void align_put_bits(PutBitContext *s); | ||
125 | |||
126 | /** | ||
127 | * Puts the string string in the bitstream. | ||
128 | * | ||
129 | * @param terminate_string 0-terminates the written string if value is 1 | ||
130 | */ | ||
131 | void ff_put_string(PutBitContext *pb, const char *string, int terminate_string); | ||
132 | |||
133 | /** | ||
134 | * Copies the content of src to the bitstream. | ||
135 | * | ||
136 | * @param length the number of bits of src to copy | ||
137 | */ | ||
138 | void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length); | ||
139 | #endif | ||
140 | |||
141 | /** | ||
142 | * Writes up to 31 bits into a bitstream. | ||
143 | * Use put_bits32 to write 32 bits. | ||
144 | */ | ||
145 | static inline void put_bits(PutBitContext *s, int n, unsigned int value) | ||
146 | #ifndef ALT_BITSTREAM_WRITER | ||
147 | { | ||
148 | unsigned int bit_buf; | ||
149 | int bit_left; | ||
150 | |||
151 | // printf("put_bits=%d %x\n", n, value); | ||
152 | //assert(n <= 31 && value < (1U << n)); | ||
153 | |||
154 | bit_buf = s->bit_buf; | ||
155 | bit_left = s->bit_left; | ||
156 | |||
157 | // printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf); | ||
158 | /* XXX: optimize */ | ||
159 | #ifdef BITSTREAM_WRITER_LE | ||
160 | bit_buf |= value << (32 - bit_left); | ||
161 | if (n >= bit_left) { | ||
162 | #if !HAVE_FAST_UNALIGNED | ||
163 | if (3 & (intptr_t) s->buf_ptr) { | ||
164 | AV_WL32(s->buf_ptr, bit_buf); | ||
165 | } else | ||
166 | #endif | ||
167 | *(uint32_t *)s->buf_ptr = le2me_32(bit_buf); | ||
168 | s->buf_ptr+=4; | ||
169 | bit_buf = (bit_left==32)?0:value >> bit_left; | ||
170 | bit_left+=32; | ||
171 | } | ||
172 | bit_left-=n; | ||
173 | #else | ||
174 | if (n < bit_left) { | ||
175 | bit_buf = (bit_buf<<n) | value; | ||
176 | bit_left-=n; | ||
177 | } else { | ||
178 | bit_buf<<=bit_left; | ||
179 | bit_buf |= value >> (n - bit_left); | ||
180 | #if !HAVE_FAST_UNALIGNED | ||
181 | if (3 & (intptr_t) s->buf_ptr) { | ||
182 | AV_WB32(s->buf_ptr, bit_buf); | ||
183 | } else | ||
184 | #endif | ||
185 | *(uint32_t *)s->buf_ptr = be2me_32(bit_buf); | ||
186 | //printf("bitbuf = %08x\n", bit_buf); | ||
187 | s->buf_ptr+=4; | ||
188 | bit_left+=32 - n; | ||
189 | bit_buf = value; | ||
190 | } | ||
191 | #endif | ||
192 | |||
193 | s->bit_buf = bit_buf; | ||
194 | s->bit_left = bit_left; | ||
195 | } | ||
196 | #else /* ALT_BITSTREAM_WRITER defined */ | ||
197 | { | ||
198 | # ifdef ALIGNED_BITSTREAM_WRITER | ||
199 | # if ARCH_X86 | ||
200 | __asm__ volatile( | ||
201 | "movl %0, %%ecx \n\t" | ||
202 | "xorl %%eax, %%eax \n\t" | ||
203 | "shrdl %%cl, %1, %%eax \n\t" | ||
204 | "shrl %%cl, %1 \n\t" | ||
205 | "movl %0, %%ecx \n\t" | ||
206 | "shrl $3, %%ecx \n\t" | ||
207 | "andl $0xFFFFFFFC, %%ecx \n\t" | ||
208 | "bswapl %1 \n\t" | ||
209 | "orl %1, (%2, %%ecx) \n\t" | ||
210 | "bswapl %%eax \n\t" | ||
211 | "addl %3, %0 \n\t" | ||
212 | "movl %%eax, 4(%2, %%ecx) \n\t" | ||
213 | : "=&r" (s->index), "=&r" (value) | ||
214 | : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n)) | ||
215 | : "%eax", "%ecx" | ||
216 | ); | ||
217 | # else | ||
218 | int index= s->index; | ||
219 | uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5); | ||
220 | |||
221 | value<<= 32-n; | ||
222 | |||
223 | ptr[0] |= be2me_32(value>>(index&31)); | ||
224 | ptr[1] = be2me_32(value<<(32-(index&31))); | ||
225 | //if(n>24) printf("%d %d\n", n, value); | ||
226 | index+= n; | ||
227 | s->index= index; | ||
228 | # endif | ||
229 | # else //ALIGNED_BITSTREAM_WRITER | ||
230 | # if ARCH_X86 | ||
231 | __asm__ volatile( | ||
232 | "movl $7, %%ecx \n\t" | ||
233 | "andl %0, %%ecx \n\t" | ||
234 | "addl %3, %%ecx \n\t" | ||
235 | "negl %%ecx \n\t" | ||
236 | "shll %%cl, %1 \n\t" | ||
237 | "bswapl %1 \n\t" | ||
238 | "movl %0, %%ecx \n\t" | ||
239 | "shrl $3, %%ecx \n\t" | ||
240 | "orl %1, (%%ecx, %2) \n\t" | ||
241 | "addl %3, %0 \n\t" | ||
242 | "movl $0, 4(%%ecx, %2) \n\t" | ||
243 | : "=&r" (s->index), "=&r" (value) | ||
244 | : "r" (s->buf), "r" (n), "0" (s->index), "1" (value) | ||
245 | : "%ecx" | ||
246 | ); | ||
247 | # else | ||
248 | int index= s->index; | ||
249 | uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3)); | ||
250 | |||
251 | ptr[0] |= be2me_32(value<<(32-n-(index&7) )); | ||
252 | ptr[1] = 0; | ||
253 | //if(n>24) printf("%d %d\n", n, value); | ||
254 | index+= n; | ||
255 | s->index= index; | ||
256 | # endif | ||
257 | # endif //!ALIGNED_BITSTREAM_WRITER | ||
258 | } | ||
259 | #endif | ||
260 | |||
261 | static inline void put_sbits(PutBitContext *pb, int n, int32_t value) | ||
262 | { | ||
263 | //assert(n >= 0 && n <= 31); | ||
264 | |||
265 | put_bits(pb, n, value & ((1<<n)-1)); | ||
266 | } | ||
267 | |||
268 | /** | ||
269 | * Returns the pointer to the byte where the bitstream writer will put | ||
270 | * the next bit. | ||
271 | */ | ||
272 | static inline uint8_t* put_bits_ptr(PutBitContext *s) | ||
273 | { | ||
274 | #ifdef ALT_BITSTREAM_WRITER | ||
275 | return s->buf + (s->index>>3); | ||
276 | #else | ||
277 | return s->buf_ptr; | ||
278 | #endif | ||
279 | } | ||
280 | |||
281 | /** | ||
282 | * Skips the given number of bytes. | ||
283 | * PutBitContext must be flushed & aligned to a byte boundary before calling this. | ||
284 | */ | ||
285 | static inline void skip_put_bytes(PutBitContext *s, int n) | ||
286 | { | ||
287 | //assert((put_bits_count(s)&7)==0); | ||
288 | #ifdef ALT_BITSTREAM_WRITER | ||
289 | FIXME may need some cleaning of the buffer | ||
290 | s->index += n<<3; | ||
291 | #else | ||
292 | //assert(s->bit_left==32); | ||
293 | s->buf_ptr += n; | ||
294 | #endif | ||
295 | } | ||
296 | |||
297 | /** | ||
298 | * Skips the given number of bits. | ||
299 | * Must only be used if the actual values in the bitstream do not matter. | ||
300 | * If n is 0 the behavior is undefined. | ||
301 | */ | ||
302 | static inline void skip_put_bits(PutBitContext *s, int n) | ||
303 | { | ||
304 | #ifdef ALT_BITSTREAM_WRITER | ||
305 | s->index += n; | ||
306 | #else | ||
307 | s->bit_left -= n; | ||
308 | s->buf_ptr-= 4*(s->bit_left>>5); | ||
309 | s->bit_left &= 31; | ||
310 | #endif | ||
311 | } | ||
312 | |||
313 | /** | ||
314 | * Changes the end of the buffer. | ||
315 | * | ||
316 | * @param size the new size in bytes of the buffer where to put bits | ||
317 | */ | ||
318 | static inline void set_put_bits_buffer_size(PutBitContext *s, int size) | ||
319 | { | ||
320 | s->buf_end= s->buf + size; | ||
321 | } | ||
322 | |||
323 | #endif /* AVCODEC_PUT_BITS_H */ | ||