Statistics
| Branch: | Revision:

ffmpeg / libavutil / intreadwrite.h @ d370e3e9

History | View | Annotate | Download (14.1 KB)

1 f5a90186 Diego Biurrun
/*
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 98790382 Stefano Sabatini
#ifndef AVUTIL_INTREADWRITE_H
20
#define AVUTIL_INTREADWRITE_H
21 cf1e119b Reimar Döffinger
22 99545457 Måns Rullgård
#include <stdint.h>
23 86816692 Måns Rullgård
#include "libavutil/avconfig.h"
24 7918375f Måns Rullgård
#include "attributes.h"
25 c08be350 Reimar Döffinger
#include "bswap.h"
26 d10458c9 Måns Rullgård
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 99545457 Måns Rullgård
48 a6783b89 Måns Rullgård
/*
49
 * Arch-specific headers can provide any combination of
50 f6d03906 Alexander Strange
 * AV_[RW][BLN](16|24|32|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 a6783b89 Måns Rullgård
 */
54
55 86816692 Måns Rullgård
#ifdef HAVE_AV_CONFIG_H
56
57
#include "config.h"
58
59 3c55ce03 Måns Rullgård
#if   ARCH_ARM
60
#   include "arm/intreadwrite.h"
61 d691da95 Måns Rullgård
#elif ARCH_AVR32
62
#   include "avr32/intreadwrite.h"
63 530456bf Måns Rullgård
#elif ARCH_MIPS
64
#   include "mips/intreadwrite.h"
65 9f5ff83f Måns Rullgård
#elif ARCH_PPC
66
#   include "ppc/intreadwrite.h"
67 95c0d02d Måns Rullgård
#elif ARCH_TOMI
68
#   include "tomi/intreadwrite.h"
69 f6d03906 Alexander Strange
#elif ARCH_X86
70
#   include "x86/intreadwrite.h"
71 3c55ce03 Måns Rullgård
#endif
72 a6783b89 Måns Rullgård
73 86816692 Måns Rullgård
#endif /* HAVE_AV_CONFIG_H */
74
75 a6783b89 Måns Rullgård
/*
76 63826ceb Måns Rullgård
 * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers.
77
 */
78
79 86816692 Måns Rullgård
#if AV_HAVE_BIGENDIAN
80 63826ceb Måns Rullgård
81
#   if    defined(AV_RN16) && !defined(AV_RB16)
82
#       define AV_RB16(p) AV_RN16(p)
83
#   elif !defined(AV_RN16) &&  defined(AV_RB16)
84
#       define AV_RN16(p) AV_RB16(p)
85
#   endif
86
87
#   if    defined(AV_WN16) && !defined(AV_WB16)
88
#       define AV_WB16(p, v) AV_WN16(p, v)
89
#   elif !defined(AV_WN16) &&  defined(AV_WB16)
90
#       define AV_WN16(p, v) AV_WB16(p, v)
91
#   endif
92
93
#   if    defined(AV_RN24) && !defined(AV_RB24)
94
#       define AV_RB24(p) AV_RN24(p)
95
#   elif !defined(AV_RN24) &&  defined(AV_RB24)
96
#       define AV_RN24(p) AV_RB24(p)
97
#   endif
98
99
#   if    defined(AV_WN24) && !defined(AV_WB24)
100
#       define AV_WB24(p, v) AV_WN24(p, v)
101
#   elif !defined(AV_WN24) &&  defined(AV_WB24)
102
#       define AV_WN24(p, v) AV_WB24(p, v)
103
#   endif
104
105 4a051891 Måns Rullgård
#   if    defined(AV_RN32) && !defined(AV_RB32)
106
#       define AV_RB32(p) AV_RN32(p)
107
#   elif !defined(AV_RN32) &&  defined(AV_RB32)
108
#       define AV_RN32(p) AV_RB32(p)
109
#   endif
110
111 63826ceb Måns Rullgård
#   if    defined(AV_WN32) && !defined(AV_WB32)
112
#       define AV_WB32(p, v) AV_WN32(p, v)
113
#   elif !defined(AV_WN32) &&  defined(AV_WB32)
114
#       define AV_WN32(p, v) AV_WB32(p, v)
115
#   endif
116
117
#   if    defined(AV_RN64) && !defined(AV_RB64)
118
#       define AV_RB64(p) AV_RN64(p)
119
#   elif !defined(AV_RN64) &&  defined(AV_RB64)
120
#       define AV_RN64(p) AV_RB64(p)
121
#   endif
122
123
#   if    defined(AV_WN64) && !defined(AV_WB64)
124
#       define AV_WB64(p, v) AV_WN64(p, v)
125
#   elif !defined(AV_WN64) &&  defined(AV_WB64)
126
#       define AV_WN64(p, v) AV_WB64(p, v)
127
#   endif
128
129 86816692 Måns Rullgård
#else /* AV_HAVE_BIGENDIAN */
130 63826ceb Måns Rullgård
131
#   if    defined(AV_RN16) && !defined(AV_RL16)
132
#       define AV_RL16(p) AV_RN16(p)
133
#   elif !defined(AV_RN16) &&  defined(AV_RL16)
134
#       define AV_RN16(p) AV_RL16(p)
135
#   endif
136
137
#   if    defined(AV_WN16) && !defined(AV_WL16)
138
#       define AV_WL16(p, v) AV_WN16(p, v)
139
#   elif !defined(AV_WN16) &&  defined(AV_WL16)
140
#       define AV_WN16(p, v) AV_WL16(p, v)
141
#   endif
142
143
#   if    defined(AV_RN24) && !defined(AV_RL24)
144
#       define AV_RL24(p) AV_RN24(p)
145
#   elif !defined(AV_RN24) &&  defined(AV_RL24)
146
#       define AV_RN24(p) AV_RL24(p)
147
#   endif
148
149
#   if    defined(AV_WN24) && !defined(AV_WL24)
150
#       define AV_WL24(p, v) AV_WN24(p, v)
151
#   elif !defined(AV_WN24) &&  defined(AV_WL24)
152
#       define AV_WN24(p, v) AV_WL24(p, v)
153
#   endif
154
155 4a051891 Måns Rullgård
#   if    defined(AV_RN32) && !defined(AV_RL32)
156
#       define AV_RL32(p) AV_RN32(p)
157
#   elif !defined(AV_RN32) &&  defined(AV_RL32)
158
#       define AV_RN32(p) AV_RL32(p)
159
#   endif
160
161 63826ceb Måns Rullgård
#   if    defined(AV_WN32) && !defined(AV_WL32)
162
#       define AV_WL32(p, v) AV_WN32(p, v)
163
#   elif !defined(AV_WN32) &&  defined(AV_WL32)
164
#       define AV_WN32(p, v) AV_WL32(p, v)
165
#   endif
166
167
#   if    defined(AV_RN64) && !defined(AV_RL64)
168
#       define AV_RL64(p) AV_RN64(p)
169
#   elif !defined(AV_RN64) &&  defined(AV_RL64)
170
#       define AV_RN64(p) AV_RL64(p)
171
#   endif
172
173
#   if    defined(AV_WN64) && !defined(AV_WL64)
174
#       define AV_WL64(p, v) AV_WN64(p, v)
175
#   elif !defined(AV_WN64) &&  defined(AV_WL64)
176
#       define AV_WN64(p, v) AV_WL64(p, v)
177
#   endif
178
179 86816692 Måns Rullgård
#endif /* !AV_HAVE_BIGENDIAN */
180 63826ceb Måns Rullgård
181
/*
182 a6783b89 Måns Rullgård
 * Define AV_[RW]N helper macros to simplify definitions not provided
183
 * by per-arch headers.
184
 */
185
186 86816692 Måns Rullgård
#if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__)
187 cf1e119b Reimar Döffinger
188 0c76e635 Måns Rullgård
union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias;
189
union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias;
190
union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
191 cf1e119b Reimar Döffinger
192 0c76e635 Måns Rullgård
#   define AV_RN(s, p) (((const union unaligned_##s *) (p))->l)
193
#   define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v))
194 cf1e119b Reimar Döffinger
195 b7b38fb2 Måns Rullgård
#elif defined(__DECC)
196
197 a6783b89 Måns Rullgård
#   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
198 c2521027 Måns Rullgård
#   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
199 fbbea48e Måns Rullgård
200 86816692 Måns Rullgård
#elif AV_HAVE_FAST_UNALIGNED
201 fbbea48e Måns Rullgård
202 0c76e635 Måns Rullgård
#   define AV_RN(s, p) (((const av_alias##s*)(p))->u##s)
203 3d7b94ba Måns Rullgård
#   define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v))
204 fbbea48e Måns Rullgård
205 a6783b89 Måns Rullgård
#else
206 fbbea48e Måns Rullgård
207 a6783b89 Måns Rullgård
#ifndef AV_RB16
208 4a051891 Måns Rullgård
#   define AV_RB16(x)                           \
209
    ((((const uint8_t*)(x))[0] << 8) |          \
210
      ((const uint8_t*)(x))[1])
211 a6783b89 Måns Rullgård
#endif
212
#ifndef AV_WB16
213 4a051891 Måns Rullgård
#   define AV_WB16(p, d) do {                   \
214
        ((uint8_t*)(p))[1] = (d);               \
215
        ((uint8_t*)(p))[0] = (d)>>8;            \
216
    } while(0)
217 a6783b89 Måns Rullgård
#endif
218 a3550abd Alex Beregszaszi
219 a6783b89 Måns Rullgård
#ifndef AV_RL16
220 4a051891 Måns Rullgård
#   define AV_RL16(x)                           \
221
    ((((const uint8_t*)(x))[1] << 8) |          \
222
      ((const uint8_t*)(x))[0])
223 a6783b89 Måns Rullgård
#endif
224
#ifndef AV_WL16
225 4a051891 Måns Rullgård
#   define AV_WL16(p, d) do {                   \
226
        ((uint8_t*)(p))[0] = (d);               \
227
        ((uint8_t*)(p))[1] = (d)>>8;            \
228
    } while(0)
229 a6783b89 Måns Rullgård
#endif
230 7b829d2a Ramiro Polla
231 a6783b89 Måns Rullgård
#ifndef AV_RB32
232 4a051891 Måns Rullgård
#   define AV_RB32(x)                           \
233
    ((((const uint8_t*)(x))[0] << 24) |         \
234
     (((const uint8_t*)(x))[1] << 16) |         \
235
     (((const uint8_t*)(x))[2] <<  8) |         \
236
      ((const uint8_t*)(x))[3])
237 a6783b89 Måns Rullgård
#endif
238
#ifndef AV_WB32
239 4a051891 Måns Rullgård
#   define AV_WB32(p, d) do {                   \
240
        ((uint8_t*)(p))[3] = (d);               \
241
        ((uint8_t*)(p))[2] = (d)>>8;            \
242
        ((uint8_t*)(p))[1] = (d)>>16;           \
243
        ((uint8_t*)(p))[0] = (d)>>24;           \
244
    } while(0)
245 a6783b89 Måns Rullgård
#endif
246 a3550abd Alex Beregszaszi
247 a6783b89 Måns Rullgård
#ifndef AV_RL32
248 4a051891 Måns Rullgård
#   define AV_RL32(x)                           \
249
    ((((const uint8_t*)(x))[3] << 24) |         \
250
     (((const uint8_t*)(x))[2] << 16) |         \
251
     (((const uint8_t*)(x))[1] <<  8) |         \
252
      ((const uint8_t*)(x))[0])
253 a6783b89 Måns Rullgård
#endif
254
#ifndef AV_WL32
255 4a051891 Måns Rullgård
#   define AV_WL32(p, d) do {                   \
256
        ((uint8_t*)(p))[0] = (d);               \
257
        ((uint8_t*)(p))[1] = (d)>>8;            \
258
        ((uint8_t*)(p))[2] = (d)>>16;           \
259
        ((uint8_t*)(p))[3] = (d)>>24;           \
260
    } while(0)
261 a6783b89 Måns Rullgård
#endif
262 9e010b41 Ivo van Poorten
263 a6783b89 Måns Rullgård
#ifndef AV_RB64
264 4a051891 Måns Rullgård
#   define AV_RB64(x)                                   \
265
    (((uint64_t)((const uint8_t*)(x))[0] << 56) |       \
266
     ((uint64_t)((const uint8_t*)(x))[1] << 48) |       \
267
     ((uint64_t)((const uint8_t*)(x))[2] << 40) |       \
268
     ((uint64_t)((const uint8_t*)(x))[3] << 32) |       \
269
     ((uint64_t)((const uint8_t*)(x))[4] << 24) |       \
270
     ((uint64_t)((const uint8_t*)(x))[5] << 16) |       \
271
     ((uint64_t)((const uint8_t*)(x))[6] <<  8) |       \
272
      (uint64_t)((const uint8_t*)(x))[7])
273 a6783b89 Måns Rullgård
#endif
274
#ifndef AV_WB64
275 4a051891 Måns Rullgård
#   define AV_WB64(p, d) do {                   \
276
        ((uint8_t*)(p))[7] = (d);               \
277
        ((uint8_t*)(p))[6] = (d)>>8;            \
278
        ((uint8_t*)(p))[5] = (d)>>16;           \
279
        ((uint8_t*)(p))[4] = (d)>>24;           \
280
        ((uint8_t*)(p))[3] = (d)>>32;           \
281
        ((uint8_t*)(p))[2] = (d)>>40;           \
282
        ((uint8_t*)(p))[1] = (d)>>48;           \
283
        ((uint8_t*)(p))[0] = (d)>>56;           \
284
    } while(0)
285 a6783b89 Måns Rullgård
#endif
286 9e010b41 Ivo van Poorten
287 a6783b89 Måns Rullgård
#ifndef AV_RL64
288 4a051891 Måns Rullgård
#   define AV_RL64(x)                                   \
289
    (((uint64_t)((const uint8_t*)(x))[7] << 56) |       \
290
     ((uint64_t)((const uint8_t*)(x))[6] << 48) |       \
291
     ((uint64_t)((const uint8_t*)(x))[5] << 40) |       \
292
     ((uint64_t)((const uint8_t*)(x))[4] << 32) |       \
293
     ((uint64_t)((const uint8_t*)(x))[3] << 24) |       \
294
     ((uint64_t)((const uint8_t*)(x))[2] << 16) |       \
295
     ((uint64_t)((const uint8_t*)(x))[1] <<  8) |       \
296
      (uint64_t)((const uint8_t*)(x))[0])
297 a6783b89 Måns Rullgård
#endif
298
#ifndef AV_WL64
299 4a051891 Måns Rullgård
#   define AV_WL64(p, d) do {                   \
300
        ((uint8_t*)(p))[0] = (d);               \
301
        ((uint8_t*)(p))[1] = (d)>>8;            \
302
        ((uint8_t*)(p))[2] = (d)>>16;           \
303
        ((uint8_t*)(p))[3] = (d)>>24;           \
304
        ((uint8_t*)(p))[4] = (d)>>32;           \
305
        ((uint8_t*)(p))[5] = (d)>>40;           \
306
        ((uint8_t*)(p))[6] = (d)>>48;           \
307
        ((uint8_t*)(p))[7] = (d)>>56;           \
308
    } while(0)
309 a6783b89 Måns Rullgård
#endif
310
311 86816692 Måns Rullgård
#if AV_HAVE_BIGENDIAN
312 a6783b89 Måns Rullgård
#   define AV_RN(s, p)    AV_RB##s(p)
313
#   define AV_WN(s, p, v) AV_WB##s(p, v)
314
#else
315
#   define AV_RN(s, p)    AV_RL##s(p)
316
#   define AV_WN(s, p, v) AV_WL##s(p, v)
317
#endif
318
319
#endif /* HAVE_FAST_UNALIGNED */
320
321
#ifndef AV_RN16
322
#   define AV_RN16(p) AV_RN(16, p)
323
#endif
324
325
#ifndef AV_RN32
326
#   define AV_RN32(p) AV_RN(32, p)
327
#endif
328
329
#ifndef AV_RN64
330
#   define AV_RN64(p) AV_RN(64, p)
331
#endif
332
333
#ifndef AV_WN16
334
#   define AV_WN16(p, v) AV_WN(16, p, v)
335
#endif
336
337
#ifndef AV_WN32
338
#   define AV_WN32(p, v) AV_WN(32, p, v)
339
#endif
340
341
#ifndef AV_WN64
342
#   define AV_WN64(p, v) AV_WN(64, p, v)
343
#endif
344
345 86816692 Måns Rullgård
#if AV_HAVE_BIGENDIAN
346 63826ceb Måns Rullgård
#   define AV_RB(s, p)    AV_RN##s(p)
347
#   define AV_WB(s, p, v) AV_WN##s(p, v)
348 8fc0162a Måns Rullgård
#   define AV_RL(s, p)    av_bswap##s(AV_RN##s(p))
349
#   define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v))
350 a6783b89 Måns Rullgård
#else
351 8fc0162a Måns Rullgård
#   define AV_RB(s, p)    av_bswap##s(AV_RN##s(p))
352
#   define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v))
353 63826ceb Måns Rullgård
#   define AV_RL(s, p)    AV_RN##s(p)
354
#   define AV_WL(s, p, v) AV_WN##s(p, v)
355 a6783b89 Måns Rullgård
#endif
356
357
#define AV_RB8(x)     (((const uint8_t*)(x))[0])
358
#define AV_WB8(p, d)  do { ((uint8_t*)(p))[0] = (d); } while(0)
359
360
#define AV_RL8(x)     AV_RB8(x)
361
#define AV_WL8(p, d)  AV_WB8(p, d)
362
363
#ifndef AV_RB16
364
#   define AV_RB16(p)    AV_RB(16, p)
365
#endif
366
#ifndef AV_WB16
367
#   define AV_WB16(p, v) AV_WB(16, p, v)
368
#endif
369
370
#ifndef AV_RL16
371
#   define AV_RL16(p)    AV_RL(16, p)
372
#endif
373
#ifndef AV_WL16
374
#   define AV_WL16(p, v) AV_WL(16, p, v)
375
#endif
376
377
#ifndef AV_RB32
378
#   define AV_RB32(p)    AV_RB(32, p)
379
#endif
380
#ifndef AV_WB32
381
#   define AV_WB32(p, v) AV_WB(32, p, v)
382
#endif
383
384
#ifndef AV_RL32
385
#   define AV_RL32(p)    AV_RL(32, p)
386
#endif
387
#ifndef AV_WL32
388
#   define AV_WL32(p, v) AV_WL(32, p, v)
389
#endif
390
391
#ifndef AV_RB64
392
#   define AV_RB64(p)    AV_RB(64, p)
393
#endif
394
#ifndef AV_WB64
395
#   define AV_WB64(p, v) AV_WB(64, p, v)
396
#endif
397
398
#ifndef AV_RL64
399
#   define AV_RL64(p)    AV_RL(64, p)
400
#endif
401
#ifndef AV_WL64
402
#   define AV_WL64(p, v) AV_WL(64, p, v)
403
#endif
404 fbbea48e Måns Rullgård
405 57c36bdc Måns Rullgård
#ifndef AV_RB24
406 4a051891 Måns Rullgård
#   define AV_RB24(x)                           \
407
    ((((const uint8_t*)(x))[0] << 16) |         \
408
     (((const uint8_t*)(x))[1] <<  8) |         \
409
      ((const uint8_t*)(x))[2])
410 57c36bdc Måns Rullgård
#endif
411
#ifndef AV_WB24
412 4a051891 Måns Rullgård
#   define AV_WB24(p, d) do {                   \
413
        ((uint8_t*)(p))[2] = (d);               \
414
        ((uint8_t*)(p))[1] = (d)>>8;            \
415
        ((uint8_t*)(p))[0] = (d)>>16;           \
416
    } while(0)
417 57c36bdc Måns Rullgård
#endif
418 fbbea48e Måns Rullgård
419 57c36bdc Måns Rullgård
#ifndef AV_RL24
420 4a051891 Måns Rullgård
#   define AV_RL24(x)                           \
421
    ((((const uint8_t*)(x))[2] << 16) |         \
422
     (((const uint8_t*)(x))[1] <<  8) |         \
423
      ((const uint8_t*)(x))[0])
424 57c36bdc Måns Rullgård
#endif
425
#ifndef AV_WL24
426 4a051891 Måns Rullgård
#   define AV_WL24(p, d) do {                   \
427
        ((uint8_t*)(p))[0] = (d);               \
428
        ((uint8_t*)(p))[1] = (d)>>8;            \
429
        ((uint8_t*)(p))[2] = (d)>>16;           \
430
    } while(0)
431 57c36bdc Måns Rullgård
#endif
432 9e010b41 Ivo van Poorten
433 f4a7434f Måns Rullgård
/*
434
 * The AV_[RW]NA macros access naturally aligned data
435
 * in a type-safe way.
436
 */
437
438
#define AV_RNA(s, p)    (((const av_alias##s*)(p))->u##s)
439
#define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v))
440
441
#ifndef AV_RN16A
442
#   define AV_RN16A(p) AV_RNA(16, p)
443
#endif
444
445
#ifndef AV_RN32A
446
#   define AV_RN32A(p) AV_RNA(32, p)
447
#endif
448
449
#ifndef AV_RN64A
450
#   define AV_RN64A(p) AV_RNA(64, p)
451
#endif
452
453
#ifndef AV_WN16A
454
#   define AV_WN16A(p, v) AV_WNA(16, p, v)
455
#endif
456
457
#ifndef AV_WN32A
458
#   define AV_WN32A(p, v) AV_WNA(32, p, v)
459
#endif
460
461
#ifndef AV_WN64A
462
#   define AV_WN64A(p, v) AV_WNA(64, p, v)
463
#endif
464
465 f6d03906 Alexander Strange
/* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be
466
 * naturally aligned. They may be implemented using MMX,
467
 * so emms_c() must be called before using any float code
468
 * afterwards.
469
 */
470
471 7a6053ef Måns Rullgård
#define AV_COPY(n, d, s) \
472
    (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n)
473 f6d03906 Alexander Strange
474 8ef4e65e Michael Niedermayer
#ifndef AV_COPY16
475
#   define AV_COPY16(d, s) AV_COPY(16, d, s)
476
#endif
477
478 6c88973a Måns Rullgård
#ifndef AV_COPY32
479
#   define AV_COPY32(d, s) AV_COPY(32, d, s)
480
#endif
481
482 f6d03906 Alexander Strange
#ifndef AV_COPY64
483
#   define AV_COPY64(d, s) AV_COPY(64, d, s)
484
#endif
485
486
#ifndef AV_COPY128
487
#   define AV_COPY128(d, s)                    \
488
    do {                                       \
489
        AV_COPY64(d, s);                       \
490
        AV_COPY64((char*)(d)+8, (char*)(s)+8); \
491
    } while(0)
492
#endif
493
494 7a6053ef Måns Rullgård
#define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b))
495 f6d03906 Alexander Strange
496
#ifndef AV_SWAP64
497
#   define AV_SWAP64(a, b) AV_SWAP(64, a, b)
498
#endif
499
500 7a6053ef Måns Rullgård
#define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0)
501
502 8ef4e65e Michael Niedermayer
#ifndef AV_ZERO16
503
#   define AV_ZERO16(d) AV_ZERO(16, d)
504
#endif
505
506 7a6053ef Måns Rullgård
#ifndef AV_ZERO32
507
#   define AV_ZERO32(d) AV_ZERO(32, d)
508
#endif
509 f6d03906 Alexander Strange
510
#ifndef AV_ZERO64
511
#   define AV_ZERO64(d) AV_ZERO(64, d)
512
#endif
513
514
#ifndef AV_ZERO128
515
#   define AV_ZERO128(d)         \
516
    do {                         \
517
        AV_ZERO64(d);            \
518
        AV_ZERO64((char*)(d)+8); \
519
    } while(0)
520
#endif
521
522 98790382 Stefano Sabatini
#endif /* AVUTIL_INTREADWRITE_H */