Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | #include "libavutil/avconfig.h" | |
24 | #include "attributes.h" | |
25 | #include "bswap.h" | |
26 | ||
27 | typedef union { | |
28 | uint64_t u64; | |
29 | uint32_t u32[2]; | |
30 | uint16_t u16[4]; | |
31 | uint8_t u8 [8]; | |
32 | double f64; | |
33 | float f32[2]; | |
34 | } av_alias av_alias64; | |
35 | ||
36 | typedef union { | |
37 | uint32_t u32; | |
38 | uint16_t u16[2]; | |
39 | uint8_t u8 [4]; | |
40 | float f32; | |
41 | } av_alias av_alias32; | |
42 | ||
43 | typedef union { | |
44 | uint16_t u16; | |
45 | uint8_t u8 [2]; | |
46 | } av_alias av_alias16; | |
47 | ||
48 | /* | |
49 | * Arch-specific headers can provide any combination of | |
50 | * AV_[RW][BLN](16|24|32|48|64) and AV_(COPY|SWAP|ZERO)(64|128) macros. | |
51 | * Preprocessor symbols must be defined, even if these are implemented | |
52 | * as inline functions. | |
53 | * | |
54 | * R/W means read/write, B/L/N means big/little/native endianness. | |
55 | * The following macros require aligned access, compared to their | |
56 | * unaligned variants: AV_(COPY|SWAP|ZERO)(64|128), AV_[RW]N[8-64]A. | |
57 | * Incorrect usage may range from abysmal performance to crash | |
58 | * depending on the platform. | |
59 | * | |
60 | * The unaligned variants are AV_[RW][BLN][8-64] and AV_COPY*U. | |
61 | */ | |
62 | ||
63 | #ifdef HAVE_AV_CONFIG_H | |
64 | ||
65 | #include "config.h" | |
66 | ||
67 | #if ARCH_ARM | |
68 | # include "arm/intreadwrite.h" | |
69 | #elif ARCH_AVR32 | |
70 | # include "avr32/intreadwrite.h" | |
71 | #elif ARCH_MIPS | |
72 | # include "mips/intreadwrite.h" | |
73 | #elif ARCH_PPC | |
74 | # include "ppc/intreadwrite.h" | |
75 | #elif ARCH_TOMI | |
76 | # include "tomi/intreadwrite.h" | |
77 | #elif ARCH_X86 | |
78 | # include "x86/intreadwrite.h" | |
79 | #endif | |
80 | ||
81 | #endif /* HAVE_AV_CONFIG_H */ | |
82 | ||
83 | /* | |
84 | * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers. | |
85 | */ | |
86 | ||
87 | #if AV_HAVE_BIGENDIAN | |
88 | ||
89 | # if defined(AV_RN16) && !defined(AV_RB16) | |
90 | # define AV_RB16(p) AV_RN16(p) | |
91 | # elif !defined(AV_RN16) && defined(AV_RB16) | |
92 | # define AV_RN16(p) AV_RB16(p) | |
93 | # endif | |
94 | ||
95 | # if defined(AV_WN16) && !defined(AV_WB16) | |
96 | # define AV_WB16(p, v) AV_WN16(p, v) | |
97 | # elif !defined(AV_WN16) && defined(AV_WB16) | |
98 | # define AV_WN16(p, v) AV_WB16(p, v) | |
99 | # endif | |
100 | ||
101 | # if defined(AV_RN24) && !defined(AV_RB24) | |
102 | # define AV_RB24(p) AV_RN24(p) | |
103 | # elif !defined(AV_RN24) && defined(AV_RB24) | |
104 | # define AV_RN24(p) AV_RB24(p) | |
105 | # endif | |
106 | ||
107 | # if defined(AV_WN24) && !defined(AV_WB24) | |
108 | # define AV_WB24(p, v) AV_WN24(p, v) | |
109 | # elif !defined(AV_WN24) && defined(AV_WB24) | |
110 | # define AV_WN24(p, v) AV_WB24(p, v) | |
111 | # endif | |
112 | ||
113 | # if defined(AV_RN32) && !defined(AV_RB32) | |
114 | # define AV_RB32(p) AV_RN32(p) | |
115 | # elif !defined(AV_RN32) && defined(AV_RB32) | |
116 | # define AV_RN32(p) AV_RB32(p) | |
117 | # endif | |
118 | ||
119 | # if defined(AV_WN32) && !defined(AV_WB32) | |
120 | # define AV_WB32(p, v) AV_WN32(p, v) | |
121 | # elif !defined(AV_WN32) && defined(AV_WB32) | |
122 | # define AV_WN32(p, v) AV_WB32(p, v) | |
123 | # endif | |
124 | ||
125 | # if defined(AV_RN48) && !defined(AV_RB48) | |
126 | # define AV_RB48(p) AV_RN48(p) | |
127 | # elif !defined(AV_RN48) && defined(AV_RB48) | |
128 | # define AV_RN48(p) AV_RB48(p) | |
129 | # endif | |
130 | ||
131 | # if defined(AV_WN48) && !defined(AV_WB48) | |
132 | # define AV_WB48(p, v) AV_WN48(p, v) | |
133 | # elif !defined(AV_WN48) && defined(AV_WB48) | |
134 | # define AV_WN48(p, v) AV_WB48(p, v) | |
135 | # endif | |
136 | ||
137 | # if defined(AV_RN64) && !defined(AV_RB64) | |
138 | # define AV_RB64(p) AV_RN64(p) | |
139 | # elif !defined(AV_RN64) && defined(AV_RB64) | |
140 | # define AV_RN64(p) AV_RB64(p) | |
141 | # endif | |
142 | ||
143 | # if defined(AV_WN64) && !defined(AV_WB64) | |
144 | # define AV_WB64(p, v) AV_WN64(p, v) | |
145 | # elif !defined(AV_WN64) && defined(AV_WB64) | |
146 | # define AV_WN64(p, v) AV_WB64(p, v) | |
147 | # endif | |
148 | ||
149 | #else /* AV_HAVE_BIGENDIAN */ | |
150 | ||
151 | # if defined(AV_RN16) && !defined(AV_RL16) | |
152 | # define AV_RL16(p) AV_RN16(p) | |
153 | # elif !defined(AV_RN16) && defined(AV_RL16) | |
154 | # define AV_RN16(p) AV_RL16(p) | |
155 | # endif | |
156 | ||
157 | # if defined(AV_WN16) && !defined(AV_WL16) | |
158 | # define AV_WL16(p, v) AV_WN16(p, v) | |
159 | # elif !defined(AV_WN16) && defined(AV_WL16) | |
160 | # define AV_WN16(p, v) AV_WL16(p, v) | |
161 | # endif | |
162 | ||
163 | # if defined(AV_RN24) && !defined(AV_RL24) | |
164 | # define AV_RL24(p) AV_RN24(p) | |
165 | # elif !defined(AV_RN24) && defined(AV_RL24) | |
166 | # define AV_RN24(p) AV_RL24(p) | |
167 | # endif | |
168 | ||
169 | # if defined(AV_WN24) && !defined(AV_WL24) | |
170 | # define AV_WL24(p, v) AV_WN24(p, v) | |
171 | # elif !defined(AV_WN24) && defined(AV_WL24) | |
172 | # define AV_WN24(p, v) AV_WL24(p, v) | |
173 | # endif | |
174 | ||
175 | # if defined(AV_RN32) && !defined(AV_RL32) | |
176 | # define AV_RL32(p) AV_RN32(p) | |
177 | # elif !defined(AV_RN32) && defined(AV_RL32) | |
178 | # define AV_RN32(p) AV_RL32(p) | |
179 | # endif | |
180 | ||
181 | # if defined(AV_WN32) && !defined(AV_WL32) | |
182 | # define AV_WL32(p, v) AV_WN32(p, v) | |
183 | # elif !defined(AV_WN32) && defined(AV_WL32) | |
184 | # define AV_WN32(p, v) AV_WL32(p, v) | |
185 | # endif | |
186 | ||
187 | # if defined(AV_RN48) && !defined(AV_RL48) | |
188 | # define AV_RL48(p) AV_RN48(p) | |
189 | # elif !defined(AV_RN48) && defined(AV_RL48) | |
190 | # define AV_RN48(p) AV_RL48(p) | |
191 | # endif | |
192 | ||
193 | # if defined(AV_WN48) && !defined(AV_WL48) | |
194 | # define AV_WL48(p, v) AV_WN48(p, v) | |
195 | # elif !defined(AV_WN48) && defined(AV_WL48) | |
196 | # define AV_WN48(p, v) AV_WL48(p, v) | |
197 | # endif | |
198 | ||
199 | # if defined(AV_RN64) && !defined(AV_RL64) | |
200 | # define AV_RL64(p) AV_RN64(p) | |
201 | # elif !defined(AV_RN64) && defined(AV_RL64) | |
202 | # define AV_RN64(p) AV_RL64(p) | |
203 | # endif | |
204 | ||
205 | # if defined(AV_WN64) && !defined(AV_WL64) | |
206 | # define AV_WL64(p, v) AV_WN64(p, v) | |
207 | # elif !defined(AV_WN64) && defined(AV_WL64) | |
208 | # define AV_WN64(p, v) AV_WL64(p, v) | |
209 | # endif | |
210 | ||
211 | #endif /* !AV_HAVE_BIGENDIAN */ | |
212 | ||
213 | /* | |
214 | * Define AV_[RW]N helper macros to simplify definitions not provided | |
215 | * by per-arch headers. | |
216 | */ | |
217 | ||
218 | #if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__) | |
219 | ||
220 | union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias; | |
221 | union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias; | |
222 | union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias; | |
223 | ||
224 | # define AV_RN(s, p) (((const union unaligned_##s *) (p))->l) | |
225 | # define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v)) | |
226 | ||
227 | #elif defined(__DECC) | |
228 | ||
229 | # define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) | |
230 | # define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) | |
231 | ||
232 | #elif AV_HAVE_FAST_UNALIGNED | |
233 | ||
234 | # define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) | |
235 | # define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) | |
236 | ||
237 | #else | |
238 | ||
239 | #ifndef AV_RB16 | |
240 | # define AV_RB16(x) \ | |
241 | ((((const uint8_t*)(x))[0] << 8) | \ | |
242 | ((const uint8_t*)(x))[1]) | |
243 | #endif | |
244 | #ifndef AV_WB16 | |
245 | # define AV_WB16(p, darg) do { \ | |
246 | unsigned d = (darg); \ | |
247 | ((uint8_t*)(p))[1] = (d); \ | |
248 | ((uint8_t*)(p))[0] = (d)>>8; \ | |
249 | } while(0) | |
250 | #endif | |
251 | ||
252 | #ifndef AV_RL16 | |
253 | # define AV_RL16(x) \ | |
254 | ((((const uint8_t*)(x))[1] << 8) | \ | |
255 | ((const uint8_t*)(x))[0]) | |
256 | #endif | |
257 | #ifndef AV_WL16 | |
258 | # define AV_WL16(p, darg) do { \ | |
259 | unsigned d = (darg); \ | |
260 | ((uint8_t*)(p))[0] = (d); \ | |
261 | ((uint8_t*)(p))[1] = (d)>>8; \ | |
262 | } while(0) | |
263 | #endif | |
264 | ||
265 | #ifndef AV_RB32 | |
266 | # define AV_RB32(x) \ | |
267 | (((uint32_t)((const uint8_t*)(x))[0] << 24) | \ | |
268 | (((const uint8_t*)(x))[1] << 16) | \ | |
269 | (((const uint8_t*)(x))[2] << 8) | \ | |
270 | ((const uint8_t*)(x))[3]) | |
271 | #endif | |
272 | #ifndef AV_WB32 | |
273 | # define AV_WB32(p, darg) do { \ | |
274 | unsigned d = (darg); \ | |
275 | ((uint8_t*)(p))[3] = (d); \ | |
276 | ((uint8_t*)(p))[2] = (d)>>8; \ | |
277 | ((uint8_t*)(p))[1] = (d)>>16; \ | |
278 | ((uint8_t*)(p))[0] = (d)>>24; \ | |
279 | } while(0) | |
280 | #endif | |
281 | ||
282 | #ifndef AV_RL32 | |
283 | # define AV_RL32(x) \ | |
284 | (((uint32_t)((const uint8_t*)(x))[3] << 24) | \ | |
285 | (((const uint8_t*)(x))[2] << 16) | \ | |
286 | (((const uint8_t*)(x))[1] << 8) | \ | |
287 | ((const uint8_t*)(x))[0]) | |
288 | #endif | |
289 | #ifndef AV_WL32 | |
290 | # define AV_WL32(p, darg) do { \ | |
291 | unsigned d = (darg); \ | |
292 | ((uint8_t*)(p))[0] = (d); \ | |
293 | ((uint8_t*)(p))[1] = (d)>>8; \ | |
294 | ((uint8_t*)(p))[2] = (d)>>16; \ | |
295 | ((uint8_t*)(p))[3] = (d)>>24; \ | |
296 | } while(0) | |
297 | #endif | |
298 | ||
299 | #ifndef AV_RB64 | |
300 | # define AV_RB64(x) \ | |
301 | (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ | |
302 | ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ | |
303 | ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ | |
304 | ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ | |
305 | ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ | |
306 | ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ | |
307 | ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ | |
308 | (uint64_t)((const uint8_t*)(x))[7]) | |
309 | #endif | |
310 | #ifndef AV_WB64 | |
311 | # define AV_WB64(p, darg) do { \ | |
312 | uint64_t d = (darg); \ | |
313 | ((uint8_t*)(p))[7] = (d); \ | |
314 | ((uint8_t*)(p))[6] = (d)>>8; \ | |
315 | ((uint8_t*)(p))[5] = (d)>>16; \ | |
316 | ((uint8_t*)(p))[4] = (d)>>24; \ | |
317 | ((uint8_t*)(p))[3] = (d)>>32; \ | |
318 | ((uint8_t*)(p))[2] = (d)>>40; \ | |
319 | ((uint8_t*)(p))[1] = (d)>>48; \ | |
320 | ((uint8_t*)(p))[0] = (d)>>56; \ | |
321 | } while(0) | |
322 | #endif | |
323 | ||
324 | #ifndef AV_RL64 | |
325 | # define AV_RL64(x) \ | |
326 | (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ | |
327 | ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ | |
328 | ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ | |
329 | ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ | |
330 | ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ | |
331 | ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ | |
332 | ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ | |
333 | (uint64_t)((const uint8_t*)(x))[0]) | |
334 | #endif | |
335 | #ifndef AV_WL64 | |
336 | # define AV_WL64(p, darg) do { \ | |
337 | uint64_t d = (darg); \ | |
338 | ((uint8_t*)(p))[0] = (d); \ | |
339 | ((uint8_t*)(p))[1] = (d)>>8; \ | |
340 | ((uint8_t*)(p))[2] = (d)>>16; \ | |
341 | ((uint8_t*)(p))[3] = (d)>>24; \ | |
342 | ((uint8_t*)(p))[4] = (d)>>32; \ | |
343 | ((uint8_t*)(p))[5] = (d)>>40; \ | |
344 | ((uint8_t*)(p))[6] = (d)>>48; \ | |
345 | ((uint8_t*)(p))[7] = (d)>>56; \ | |
346 | } while(0) | |
347 | #endif | |
348 | ||
349 | #if AV_HAVE_BIGENDIAN | |
350 | # define AV_RN(s, p) AV_RB##s(p) | |
351 | # define AV_WN(s, p, v) AV_WB##s(p, v) | |
352 | #else | |
353 | # define AV_RN(s, p) AV_RL##s(p) | |
354 | # define AV_WN(s, p, v) AV_WL##s(p, v) | |
355 | #endif | |
356 | ||
357 | #endif /* HAVE_FAST_UNALIGNED */ | |
358 | ||
359 | #ifndef AV_RN16 | |
360 | # define AV_RN16(p) AV_RN(16, p) | |
361 | #endif | |
362 | ||
363 | #ifndef AV_RN32 | |
364 | # define AV_RN32(p) AV_RN(32, p) | |
365 | #endif | |
366 | ||
367 | #ifndef AV_RN64 | |
368 | # define AV_RN64(p) AV_RN(64, p) | |
369 | #endif | |
370 | ||
371 | #ifndef AV_WN16 | |
372 | # define AV_WN16(p, v) AV_WN(16, p, v) | |
373 | #endif | |
374 | ||
375 | #ifndef AV_WN32 | |
376 | # define AV_WN32(p, v) AV_WN(32, p, v) | |
377 | #endif | |
378 | ||
379 | #ifndef AV_WN64 | |
380 | # define AV_WN64(p, v) AV_WN(64, p, v) | |
381 | #endif | |
382 | ||
383 | #if AV_HAVE_BIGENDIAN | |
384 | # define AV_RB(s, p) AV_RN##s(p) | |
385 | # define AV_WB(s, p, v) AV_WN##s(p, v) | |
386 | # define AV_RL(s, p) av_bswap##s(AV_RN##s(p)) | |
387 | # define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v)) | |
388 | #else | |
389 | # define AV_RB(s, p) av_bswap##s(AV_RN##s(p)) | |
390 | # define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v)) | |
391 | # define AV_RL(s, p) AV_RN##s(p) | |
392 | # define AV_WL(s, p, v) AV_WN##s(p, v) | |
393 | #endif | |
394 | ||
395 | #define AV_RB8(x) (((const uint8_t*)(x))[0]) | |
396 | #define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) | |
397 | ||
398 | #define AV_RL8(x) AV_RB8(x) | |
399 | #define AV_WL8(p, d) AV_WB8(p, d) | |
400 | ||
401 | #ifndef AV_RB16 | |
402 | # define AV_RB16(p) AV_RB(16, p) | |
403 | #endif | |
404 | #ifndef AV_WB16 | |
405 | # define AV_WB16(p, v) AV_WB(16, p, v) | |
406 | #endif | |
407 | ||
408 | #ifndef AV_RL16 | |
409 | # define AV_RL16(p) AV_RL(16, p) | |
410 | #endif | |
411 | #ifndef AV_WL16 | |
412 | # define AV_WL16(p, v) AV_WL(16, p, v) | |
413 | #endif | |
414 | ||
415 | #ifndef AV_RB32 | |
416 | # define AV_RB32(p) AV_RB(32, p) | |
417 | #endif | |
418 | #ifndef AV_WB32 | |
419 | # define AV_WB32(p, v) AV_WB(32, p, v) | |
420 | #endif | |
421 | ||
422 | #ifndef AV_RL32 | |
423 | # define AV_RL32(p) AV_RL(32, p) | |
424 | #endif | |
425 | #ifndef AV_WL32 | |
426 | # define AV_WL32(p, v) AV_WL(32, p, v) | |
427 | #endif | |
428 | ||
429 | #ifndef AV_RB64 | |
430 | # define AV_RB64(p) AV_RB(64, p) | |
431 | #endif | |
432 | #ifndef AV_WB64 | |
433 | # define AV_WB64(p, v) AV_WB(64, p, v) | |
434 | #endif | |
435 | ||
436 | #ifndef AV_RL64 | |
437 | # define AV_RL64(p) AV_RL(64, p) | |
438 | #endif | |
439 | #ifndef AV_WL64 | |
440 | # define AV_WL64(p, v) AV_WL(64, p, v) | |
441 | #endif | |
442 | ||
443 | #ifndef AV_RB24 | |
444 | # define AV_RB24(x) \ | |
445 | ((((const uint8_t*)(x))[0] << 16) | \ | |
446 | (((const uint8_t*)(x))[1] << 8) | \ | |
447 | ((const uint8_t*)(x))[2]) | |
448 | #endif | |
449 | #ifndef AV_WB24 | |
450 | # define AV_WB24(p, d) do { \ | |
451 | ((uint8_t*)(p))[2] = (d); \ | |
452 | ((uint8_t*)(p))[1] = (d)>>8; \ | |
453 | ((uint8_t*)(p))[0] = (d)>>16; \ | |
454 | } while(0) | |
455 | #endif | |
456 | ||
457 | #ifndef AV_RL24 | |
458 | # define AV_RL24(x) \ | |
459 | ((((const uint8_t*)(x))[2] << 16) | \ | |
460 | (((const uint8_t*)(x))[1] << 8) | \ | |
461 | ((const uint8_t*)(x))[0]) | |
462 | #endif | |
463 | #ifndef AV_WL24 | |
464 | # define AV_WL24(p, d) do { \ | |
465 | ((uint8_t*)(p))[0] = (d); \ | |
466 | ((uint8_t*)(p))[1] = (d)>>8; \ | |
467 | ((uint8_t*)(p))[2] = (d)>>16; \ | |
468 | } while(0) | |
469 | #endif | |
470 | ||
471 | #ifndef AV_RB48 | |
472 | # define AV_RB48(x) \ | |
473 | (((uint64_t)((const uint8_t*)(x))[0] << 40) | \ | |
474 | ((uint64_t)((const uint8_t*)(x))[1] << 32) | \ | |
475 | ((uint64_t)((const uint8_t*)(x))[2] << 24) | \ | |
476 | ((uint64_t)((const uint8_t*)(x))[3] << 16) | \ | |
477 | ((uint64_t)((const uint8_t*)(x))[4] << 8) | \ | |
478 | (uint64_t)((const uint8_t*)(x))[5]) | |
479 | #endif | |
480 | #ifndef AV_WB48 | |
481 | # define AV_WB48(p, darg) do { \ | |
482 | uint64_t d = (darg); \ | |
483 | ((uint8_t*)(p))[5] = (d); \ | |
484 | ((uint8_t*)(p))[4] = (d)>>8; \ | |
485 | ((uint8_t*)(p))[3] = (d)>>16; \ | |
486 | ((uint8_t*)(p))[2] = (d)>>24; \ | |
487 | ((uint8_t*)(p))[1] = (d)>>32; \ | |
488 | ((uint8_t*)(p))[0] = (d)>>40; \ | |
489 | } while(0) | |
490 | #endif | |
491 | ||
492 | #ifndef AV_RL48 | |
493 | # define AV_RL48(x) \ | |
494 | (((uint64_t)((const uint8_t*)(x))[5] << 40) | \ | |
495 | ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ | |
496 | ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ | |
497 | ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ | |
498 | ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ | |
499 | (uint64_t)((const uint8_t*)(x))[0]) | |
500 | #endif | |
501 | #ifndef AV_WL48 | |
502 | # define AV_WL48(p, darg) do { \ | |
503 | uint64_t d = (darg); \ | |
504 | ((uint8_t*)(p))[0] = (d); \ | |
505 | ((uint8_t*)(p))[1] = (d)>>8; \ | |
506 | ((uint8_t*)(p))[2] = (d)>>16; \ | |
507 | ((uint8_t*)(p))[3] = (d)>>24; \ | |
508 | ((uint8_t*)(p))[4] = (d)>>32; \ | |
509 | ((uint8_t*)(p))[5] = (d)>>40; \ | |
510 | } while(0) | |
511 | #endif | |
512 | ||
513 | /* | |
514 | * The AV_[RW]NA macros access naturally aligned data | |
515 | * in a type-safe way. | |
516 | */ | |
517 | ||
518 | #define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s) | |
519 | #define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v)) | |
520 | ||
521 | #ifndef AV_RN16A | |
522 | # define AV_RN16A(p) AV_RNA(16, p) | |
523 | #endif | |
524 | ||
525 | #ifndef AV_RN32A | |
526 | # define AV_RN32A(p) AV_RNA(32, p) | |
527 | #endif | |
528 | ||
529 | #ifndef AV_RN64A | |
530 | # define AV_RN64A(p) AV_RNA(64, p) | |
531 | #endif | |
532 | ||
533 | #ifndef AV_WN16A | |
534 | # define AV_WN16A(p, v) AV_WNA(16, p, v) | |
535 | #endif | |
536 | ||
537 | #ifndef AV_WN32A | |
538 | # define AV_WN32A(p, v) AV_WNA(32, p, v) | |
539 | #endif | |
540 | ||
541 | #ifndef AV_WN64A | |
542 | # define AV_WN64A(p, v) AV_WNA(64, p, v) | |
543 | #endif | |
544 | ||
545 | /* | |
546 | * The AV_COPYxxU macros are suitable for copying data to/from unaligned | |
547 | * memory locations. | |
548 | */ | |
549 | ||
550 | #define AV_COPYU(n, d, s) AV_WN##n(d, AV_RN##n(s)); | |
551 | ||
552 | #ifndef AV_COPY16U | |
553 | # define AV_COPY16U(d, s) AV_COPYU(16, d, s) | |
554 | #endif | |
555 | ||
556 | #ifndef AV_COPY32U | |
557 | # define AV_COPY32U(d, s) AV_COPYU(32, d, s) | |
558 | #endif | |
559 | ||
560 | #ifndef AV_COPY64U | |
561 | # define AV_COPY64U(d, s) AV_COPYU(64, d, s) | |
562 | #endif | |
563 | ||
564 | #ifndef AV_COPY128U | |
565 | # define AV_COPY128U(d, s) \ | |
566 | do { \ | |
567 | AV_COPY64U(d, s); \ | |
568 | AV_COPY64U((char *)(d) + 8, (const char *)(s) + 8); \ | |
569 | } while(0) | |
570 | #endif | |
571 | ||
572 | /* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be | |
573 | * naturally aligned. They may be implemented using MMX, | |
574 | * so emms_c() must be called before using any float code | |
575 | * afterwards. | |
576 | */ | |
577 | ||
578 | #define AV_COPY(n, d, s) \ | |
579 | (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n) | |
580 | ||
581 | #ifndef AV_COPY16 | |
582 | # define AV_COPY16(d, s) AV_COPY(16, d, s) | |
583 | #endif | |
584 | ||
585 | #ifndef AV_COPY32 | |
586 | # define AV_COPY32(d, s) AV_COPY(32, d, s) | |
587 | #endif | |
588 | ||
589 | #ifndef AV_COPY64 | |
590 | # define AV_COPY64(d, s) AV_COPY(64, d, s) | |
591 | #endif | |
592 | ||
593 | #ifndef AV_COPY128 | |
594 | # define AV_COPY128(d, s) \ | |
595 | do { \ | |
596 | AV_COPY64(d, s); \ | |
597 | AV_COPY64((char*)(d)+8, (char*)(s)+8); \ | |
598 | } while(0) | |
599 | #endif | |
600 | ||
601 | #define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b)) | |
602 | ||
603 | #ifndef AV_SWAP64 | |
604 | # define AV_SWAP64(a, b) AV_SWAP(64, a, b) | |
605 | #endif | |
606 | ||
607 | #define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0) | |
608 | ||
609 | #ifndef AV_ZERO16 | |
610 | # define AV_ZERO16(d) AV_ZERO(16, d) | |
611 | #endif | |
612 | ||
613 | #ifndef AV_ZERO32 | |
614 | # define AV_ZERO32(d) AV_ZERO(32, d) | |
615 | #endif | |
616 | ||
617 | #ifndef AV_ZERO64 | |
618 | # define AV_ZERO64(d) AV_ZERO(64, d) | |
619 | #endif | |
620 | ||
621 | #ifndef AV_ZERO128 | |
622 | # define AV_ZERO128(d) \ | |
623 | do { \ | |
624 | AV_ZERO64(d); \ | |
625 | AV_ZERO64((char*)(d)+8); \ | |
626 | } while(0) | |
627 | #endif | |
628 | ||
629 | #endif /* AVUTIL_INTREADWRITE_H */ |