Mercurial > hg > forks > libbpg
comparison libavutil/intreadwrite.h @ 0:772086c29cc7
Initial import.
author | Matti Hamalainen <ccr@tnsp.org> |
---|---|
date | Wed, 16 Nov 2016 11:16:33 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:772086c29cc7 |
---|---|
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 */ |