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