Mercurial > libavutil.hg
annotate intreadwrite.h @ 1028:5dbb12a37c3d libavutil tip
Move av_set_options_string() from libavfilter to libavutil.
author | stefano |
---|---|
date | Mon, 27 Sep 2010 22:09:53 +0000 |
parents | 3ed4c58e9a0e |
children |
rev | line source |
---|---|
263 | 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 | |
567 | 19 #ifndef AVUTIL_INTREADWRITE_H |
20 #define AVUTIL_INTREADWRITE_H | |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
21 |
343 | 22 #include <stdint.h> |
995 | 23 #include "libavutil/avconfig.h" |
991
ac42d0f16eae
intreadwrite: common.h is not needed, attributes.h is sufficient
mru
parents:
854
diff
changeset
|
24 #include "attributes.h" |
350
c2034e89e9a2
intreadwrite.h needs bswap.h if HAVE_FAST_UNALIGNED is set, so include it.
reimar
parents:
343
diff
changeset
|
25 #include "bswap.h" |
837 | 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; | |
343 | 47 |
727 | 48 /* |
49 * Arch-specific headers can provide any combination of | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
50 * AV_[RW][BLN](16|24|32|64) and AV_(COPY|SWAP|ZERO)(64|128) macros. |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
51 * Preprocessor symbols must be defined, even if these are implemented |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
52 * as inline functions. |
727 | 53 */ |
54 | |
995 | 55 #ifdef HAVE_AV_CONFIG_H |
56 | |
57 #include "config.h" | |
58 | |
728 | 59 #if ARCH_ARM |
60 # include "arm/intreadwrite.h" | |
771 | 61 #elif ARCH_AVR32 |
62 # include "avr32/intreadwrite.h" | |
737 | 63 #elif ARCH_MIPS |
64 # include "mips/intreadwrite.h" | |
729 | 65 #elif ARCH_PPC |
66 # include "ppc/intreadwrite.h" | |
841 | 67 #elif ARCH_TOMI |
68 # include "tomi/intreadwrite.h" | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
69 #elif ARCH_X86 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
70 # include "x86/intreadwrite.h" |
728 | 71 #endif |
727 | 72 |
995 | 73 #endif /* HAVE_AV_CONFIG_H */ |
74 | |
727 | 75 /* |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
76 * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers. |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
77 */ |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
78 |
995 | 79 #if AV_HAVE_BIGENDIAN |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
80 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
81 # if defined(AV_RN16) && !defined(AV_RB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
82 # define AV_RB16(p) AV_RN16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
83 # elif !defined(AV_RN16) && defined(AV_RB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
84 # define AV_RN16(p) AV_RB16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
85 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
86 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
87 # if defined(AV_WN16) && !defined(AV_WB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
88 # define AV_WB16(p, v) AV_WN16(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
89 # elif !defined(AV_WN16) && defined(AV_WB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
90 # define AV_WN16(p, v) AV_WB16(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
91 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
92 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
93 # if defined(AV_RN24) && !defined(AV_RB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
94 # define AV_RB24(p) AV_RN24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
95 # elif !defined(AV_RN24) && defined(AV_RB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
96 # define AV_RN24(p) AV_RB24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
97 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
98 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
99 # if defined(AV_WN24) && !defined(AV_WB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
100 # define AV_WB24(p, v) AV_WN24(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
101 # elif !defined(AV_WN24) && defined(AV_WB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
102 # define AV_WN24(p, v) AV_WB24(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
103 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
104 |
768 | 105 # 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 | |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
111 # if defined(AV_WN32) && !defined(AV_WB32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
112 # define AV_WB32(p, v) AV_WN32(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
113 # elif !defined(AV_WN32) && defined(AV_WB32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
114 # define AV_WN32(p, v) AV_WB32(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
115 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
116 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
117 # if defined(AV_RN64) && !defined(AV_RB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
118 # define AV_RB64(p) AV_RN64(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
119 # elif !defined(AV_RN64) && defined(AV_RB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
120 # define AV_RN64(p) AV_RB64(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
121 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
122 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
123 # if defined(AV_WN64) && !defined(AV_WB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
124 # define AV_WB64(p, v) AV_WN64(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
125 # elif !defined(AV_WN64) && defined(AV_WB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
126 # define AV_WN64(p, v) AV_WB64(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
127 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
128 |
995 | 129 #else /* AV_HAVE_BIGENDIAN */ |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
130 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
131 # if defined(AV_RN16) && !defined(AV_RL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
132 # define AV_RL16(p) AV_RN16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
133 # elif !defined(AV_RN16) && defined(AV_RL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
134 # define AV_RN16(p) AV_RL16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
135 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
136 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
137 # if defined(AV_WN16) && !defined(AV_WL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
138 # define AV_WL16(p, v) AV_WN16(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
139 # elif !defined(AV_WN16) && defined(AV_WL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
140 # define AV_WN16(p, v) AV_WL16(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
141 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
142 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
143 # if defined(AV_RN24) && !defined(AV_RL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
144 # define AV_RL24(p) AV_RN24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
145 # elif !defined(AV_RN24) && defined(AV_RL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
146 # define AV_RN24(p) AV_RL24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
147 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
148 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
149 # if defined(AV_WN24) && !defined(AV_WL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
150 # define AV_WL24(p, v) AV_WN24(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
151 # elif !defined(AV_WN24) && defined(AV_WL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
152 # define AV_WN24(p, v) AV_WL24(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
153 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
154 |
768 | 155 # 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 | |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
161 # if defined(AV_WN32) && !defined(AV_WL32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
162 # define AV_WL32(p, v) AV_WN32(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
163 # elif !defined(AV_WN32) && defined(AV_WL32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
164 # define AV_WN32(p, v) AV_WL32(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
165 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
166 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
167 # if defined(AV_RN64) && !defined(AV_RL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
168 # define AV_RL64(p) AV_RN64(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
169 # elif !defined(AV_RN64) && defined(AV_RL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
170 # define AV_RN64(p) AV_RL64(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
171 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
172 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
173 # if defined(AV_WN64) && !defined(AV_WL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
174 # define AV_WL64(p, v) AV_WN64(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
175 # elif !defined(AV_WN64) && defined(AV_WL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
176 # define AV_WN64(p, v) AV_WL64(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
177 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
178 |
995 | 179 #endif /* !AV_HAVE_BIGENDIAN */ |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
180 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
181 /* |
727 | 182 * Define AV_[RW]N helper macros to simplify definitions not provided |
183 * by per-arch headers. | |
184 */ | |
185 | |
995 | 186 #if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__) |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
187 |
838 | 188 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; | |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
191 |
838 | 192 # define AV_RN(s, p) (((const union unaligned_##s *) (p))->l) |
193 # define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v)) | |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
194 |
525
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
195 #elif defined(__DECC) |
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
196 |
727 | 197 # define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) |
810 | 198 # define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) |
525
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
199 |
995 | 200 #elif AV_HAVE_FAST_UNALIGNED |
727 | 201 |
838 | 202 # define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) |
854
d6d589d11549
Fix build failure with fast_unaligned and non-gcc-compatible compilers
mru
parents:
849
diff
changeset
|
203 # define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) |
525
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
204 |
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
205 #else |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
206 |
727 | 207 #ifndef AV_RB16 |
768 | 208 # define AV_RB16(x) \ |
209 ((((const uint8_t*)(x))[0] << 8) | \ | |
210 ((const uint8_t*)(x))[1]) | |
727 | 211 #endif |
212 #ifndef AV_WB16 | |
768 | 213 # define AV_WB16(p, d) do { \ |
214 ((uint8_t*)(p))[1] = (d); \ | |
215 ((uint8_t*)(p))[0] = (d)>>8; \ | |
216 } while(0) | |
727 | 217 #endif |
232
9845a508ffbd
add AV_WB/WL for lswriting, similar to AV_RB/RL (also increment version)
alex
parents:
231
diff
changeset
|
218 |
727 | 219 #ifndef AV_RL16 |
768 | 220 # define AV_RL16(x) \ |
221 ((((const uint8_t*)(x))[1] << 8) | \ | |
222 ((const uint8_t*)(x))[0]) | |
727 | 223 #endif |
224 #ifndef AV_WL16 | |
768 | 225 # define AV_WL16(p, d) do { \ |
226 ((uint8_t*)(p))[0] = (d); \ | |
227 ((uint8_t*)(p))[1] = (d)>>8; \ | |
228 } while(0) | |
727 | 229 #endif |
326
46b4da5bf9ed
cosmetics: Reorder endianness macros by bit depth, alignment prettyprinting.
diego
parents:
282
diff
changeset
|
230 |
727 | 231 #ifndef AV_RB32 |
768 | 232 # 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]) | |
727 | 237 #endif |
238 #ifndef AV_WB32 | |
768 | 239 # 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) | |
727 | 245 #endif |
232
9845a508ffbd
add AV_WB/WL for lswriting, similar to AV_RB/RL (also increment version)
alex
parents:
231
diff
changeset
|
246 |
727 | 247 #ifndef AV_RL32 |
768 | 248 # 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]) | |
727 | 253 #endif |
254 #ifndef AV_WL32 | |
768 | 255 # 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) | |
727 | 261 #endif |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
262 |
727 | 263 #ifndef AV_RB64 |
768 | 264 # 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]) | |
727 | 273 #endif |
274 #ifndef AV_WB64 | |
768 | 275 # 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) | |
727 | 285 #endif |
335 | 286 |
727 | 287 #ifndef AV_RL64 |
768 | 288 # 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]) | |
727 | 297 #endif |
298 #ifndef AV_WL64 | |
768 | 299 # 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) | |
727 | 309 #endif |
310 | |
995 | 311 #if AV_HAVE_BIGENDIAN |
727 | 312 # 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 | |
995 | 345 #if AV_HAVE_BIGENDIAN |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
346 # define AV_RB(s, p) AV_RN##s(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
347 # define AV_WB(s, p, v) AV_WN##s(p, v) |
993 | 348 # 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)) | |
727 | 350 #else |
993 | 351 # 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)) | |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
353 # define AV_RL(s, p) AV_RN##s(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
354 # define AV_WL(s, p, v) AV_WN##s(p, v) |
727 | 355 #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 | |
524 | 404 |
766 | 405 #ifndef AV_RB24 |
768 | 406 # define AV_RB24(x) \ |
407 ((((const uint8_t*)(x))[0] << 16) | \ | |
408 (((const uint8_t*)(x))[1] << 8) | \ | |
409 ((const uint8_t*)(x))[2]) | |
766 | 410 #endif |
411 #ifndef AV_WB24 | |
768 | 412 # 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) | |
766 | 417 #endif |
524 | 418 |
766 | 419 #ifndef AV_RL24 |
768 | 420 # define AV_RL24(x) \ |
421 ((((const uint8_t*)(x))[2] << 16) | \ | |
422 (((const uint8_t*)(x))[1] << 8) | \ | |
423 ((const uint8_t*)(x))[0]) | |
766 | 424 #endif |
425 #ifndef AV_WL24 | |
768 | 426 # 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) | |
766 | 431 #endif |
335 | 432 |
840 | 433 /* |
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 | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
465 /* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
466 * naturally aligned. They may be implemented using MMX, |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
467 * so emms_c() must be called before using any float code |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
468 * afterwards. |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
469 */ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
470 |
839 | 471 #define AV_COPY(n, d, s) \ |
472 (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n) | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
473 |
849 | 474 #ifndef AV_COPY16 |
475 # define AV_COPY16(d, s) AV_COPY(16, d, s) | |
476 #endif | |
477 | |
826 | 478 #ifndef AV_COPY32 |
479 # define AV_COPY32(d, s) AV_COPY(32, d, s) | |
480 #endif | |
481 | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
482 #ifndef AV_COPY64 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
483 # define AV_COPY64(d, s) AV_COPY(64, d, s) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
484 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
485 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
486 #ifndef AV_COPY128 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
487 # define AV_COPY128(d, s) \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
488 do { \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
489 AV_COPY64(d, s); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
490 AV_COPY64((char*)(d)+8, (char*)(s)+8); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
491 } while(0) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
492 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
493 |
839 | 494 #define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b)) |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
495 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
496 #ifndef AV_SWAP64 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
497 # define AV_SWAP64(a, b) AV_SWAP(64, a, b) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
498 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
499 |
839 | 500 #define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0) |
501 | |
849 | 502 #ifndef AV_ZERO16 |
503 # define AV_ZERO16(d) AV_ZERO(16, d) | |
504 #endif | |
505 | |
839 | 506 #ifndef AV_ZERO32 |
507 # define AV_ZERO32(d) AV_ZERO(32, d) | |
508 #endif | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
509 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
510 #ifndef AV_ZERO64 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
511 # define AV_ZERO64(d) AV_ZERO(64, d) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
512 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
513 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
514 #ifndef AV_ZERO128 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
515 # define AV_ZERO128(d) \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
516 do { \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
517 AV_ZERO64(d); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
518 AV_ZERO64((char*)(d)+8); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
519 } while(0) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
520 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
521 |
567 | 522 #endif /* AVUTIL_INTREADWRITE_H */ |