Mercurial > libavutil.hg
annotate intreadwrite.h @ 813:7c4f89909560 libavutil
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
Add x86 implementation using MMX/SSE.
author | astrange |
---|---|
date | Mon, 18 Jan 2010 10:24:33 +0000 |
parents | 121e47f833b4 |
children | 5d63d070e9ff |
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> |
469 | 23 #include "config.h" |
350
c2034e89e9a2
intreadwrite.h needs bswap.h if HAVE_FAST_UNALIGNED is set, so include it.
reimar
parents:
343
diff
changeset
|
24 #include "bswap.h" |
343 | 25 |
727 | 26 /* |
27 * 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
|
28 * 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
|
29 * 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
|
30 * as inline functions. |
727 | 31 */ |
32 | |
728 | 33 #if ARCH_ARM |
34 # include "arm/intreadwrite.h" | |
771 | 35 #elif ARCH_AVR32 |
36 # include "avr32/intreadwrite.h" | |
737 | 37 #elif ARCH_MIPS |
38 # include "mips/intreadwrite.h" | |
729 | 39 #elif ARCH_PPC |
40 # include "ppc/intreadwrite.h" | |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
41 #elif ARCH_X86 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
42 # include "x86/intreadwrite.h" |
728 | 43 #endif |
727 | 44 |
45 /* | |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
46 * 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
|
47 */ |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
48 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
49 #if HAVE_BIGENDIAN |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
50 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
51 # if defined(AV_RN16) && !defined(AV_RB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
52 # define AV_RB16(p) AV_RN16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
53 # elif !defined(AV_RN16) && defined(AV_RB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
54 # define AV_RN16(p) AV_RB16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
55 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
56 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
57 # if defined(AV_WN16) && !defined(AV_WB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
58 # 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
|
59 # elif !defined(AV_WN16) && defined(AV_WB16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
60 # 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
|
61 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
62 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
63 # if defined(AV_RN24) && !defined(AV_RB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
64 # define AV_RB24(p) AV_RN24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
65 # elif !defined(AV_RN24) && defined(AV_RB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
66 # define AV_RN24(p) AV_RB24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
67 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
68 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
69 # if defined(AV_WN24) && !defined(AV_WB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
70 # 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
|
71 # elif !defined(AV_WN24) && defined(AV_WB24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
72 # 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
|
73 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
74 |
768 | 75 # if defined(AV_RN32) && !defined(AV_RB32) |
76 # define AV_RB32(p) AV_RN32(p) | |
77 # elif !defined(AV_RN32) && defined(AV_RB32) | |
78 # define AV_RN32(p) AV_RB32(p) | |
79 # endif | |
80 | |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
81 # if defined(AV_WN32) && !defined(AV_WB32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
82 # 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
|
83 # elif !defined(AV_WN32) && defined(AV_WB32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
84 # 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
|
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_RN64) && !defined(AV_RB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
88 # define AV_RB64(p) AV_RN64(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
89 # elif !defined(AV_RN64) && defined(AV_RB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
90 # define AV_RN64(p) AV_RB64(p) |
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_WN64) && !defined(AV_WB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
94 # 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
|
95 # elif !defined(AV_WN64) && defined(AV_WB64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
96 # 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
|
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 #else /* HAVE_BIGENDIAN */ |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
100 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
101 # if defined(AV_RN16) && !defined(AV_RL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
102 # define AV_RL16(p) AV_RN16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
103 # elif !defined(AV_RN16) && defined(AV_RL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
104 # define AV_RN16(p) AV_RL16(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
105 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
106 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
107 # if defined(AV_WN16) && !defined(AV_WL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
108 # 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
|
109 # elif !defined(AV_WN16) && defined(AV_WL16) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
110 # 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
|
111 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
112 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
113 # if defined(AV_RN24) && !defined(AV_RL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
114 # define AV_RL24(p) AV_RN24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
115 # elif !defined(AV_RN24) && defined(AV_RL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
116 # define AV_RN24(p) AV_RL24(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
117 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
118 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
119 # if defined(AV_WN24) && !defined(AV_WL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
120 # 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
|
121 # elif !defined(AV_WN24) && defined(AV_WL24) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
122 # 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
|
123 # endif |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
124 |
768 | 125 # if defined(AV_RN32) && !defined(AV_RL32) |
126 # define AV_RL32(p) AV_RN32(p) | |
127 # elif !defined(AV_RN32) && defined(AV_RL32) | |
128 # define AV_RN32(p) AV_RL32(p) | |
129 # endif | |
130 | |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
131 # if defined(AV_WN32) && !defined(AV_WL32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
132 # 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
|
133 # elif !defined(AV_WN32) && defined(AV_WL32) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
134 # 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
|
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_RN64) && !defined(AV_RL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
138 # define AV_RL64(p) AV_RN64(p) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
139 # elif !defined(AV_RN64) && defined(AV_RL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
140 # define AV_RN64(p) AV_RL64(p) |
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_WN64) && !defined(AV_WL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
144 # 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
|
145 # elif !defined(AV_WN64) && defined(AV_WL64) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
146 # 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
|
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 #endif /* !HAVE_BIGENDIAN */ |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
150 |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
151 /* |
727 | 152 * Define AV_[RW]N helper macros to simplify definitions not provided |
153 * by per-arch headers. | |
154 */ | |
155 | |
757 | 156 #if HAVE_ATTRIBUTE_PACKED |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
157 |
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
158 struct unaligned_64 { uint64_t l; } __attribute__((packed)); |
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
159 struct unaligned_32 { uint32_t l; } __attribute__((packed)); |
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
160 struct unaligned_16 { uint16_t l; } __attribute__((packed)); |
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
161 |
727 | 162 # define AV_RN(s, p) (((const struct unaligned_##s *) (p))->l) |
810 | 163 # define AV_WN(s, p, v) ((((struct unaligned_##s *) (p))->l) = (v)) |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
164 |
525
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
165 #elif defined(__DECC) |
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
166 |
727 | 167 # define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) |
810 | 168 # 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
|
169 |
727 | 170 #elif HAVE_FAST_UNALIGNED |
171 | |
172 # define AV_RN(s, p) (*((const uint##s##_t*)(p))) | |
810 | 173 # define AV_WN(s, p, v) (*((uint##s##_t*)(p)) = (v)) |
525
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
174 |
0d4beab5e3c9
intreadwrite: support DEC compiler __unaligned type qualifier
mru
parents:
524
diff
changeset
|
175 #else |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
176 |
727 | 177 #ifndef AV_RB16 |
768 | 178 # define AV_RB16(x) \ |
179 ((((const uint8_t*)(x))[0] << 8) | \ | |
180 ((const uint8_t*)(x))[1]) | |
727 | 181 #endif |
182 #ifndef AV_WB16 | |
768 | 183 # define AV_WB16(p, d) do { \ |
184 ((uint8_t*)(p))[1] = (d); \ | |
185 ((uint8_t*)(p))[0] = (d)>>8; \ | |
186 } while(0) | |
727 | 187 #endif |
232
9845a508ffbd
add AV_WB/WL for lswriting, similar to AV_RB/RL (also increment version)
alex
parents:
231
diff
changeset
|
188 |
727 | 189 #ifndef AV_RL16 |
768 | 190 # define AV_RL16(x) \ |
191 ((((const uint8_t*)(x))[1] << 8) | \ | |
192 ((const uint8_t*)(x))[0]) | |
727 | 193 #endif |
194 #ifndef AV_WL16 | |
768 | 195 # define AV_WL16(p, d) do { \ |
196 ((uint8_t*)(p))[0] = (d); \ | |
197 ((uint8_t*)(p))[1] = (d)>>8; \ | |
198 } while(0) | |
727 | 199 #endif |
326
46b4da5bf9ed
cosmetics: Reorder endianness macros by bit depth, alignment prettyprinting.
diego
parents:
282
diff
changeset
|
200 |
727 | 201 #ifndef AV_RB32 |
768 | 202 # define AV_RB32(x) \ |
203 ((((const uint8_t*)(x))[0] << 24) | \ | |
204 (((const uint8_t*)(x))[1] << 16) | \ | |
205 (((const uint8_t*)(x))[2] << 8) | \ | |
206 ((const uint8_t*)(x))[3]) | |
727 | 207 #endif |
208 #ifndef AV_WB32 | |
768 | 209 # define AV_WB32(p, d) do { \ |
210 ((uint8_t*)(p))[3] = (d); \ | |
211 ((uint8_t*)(p))[2] = (d)>>8; \ | |
212 ((uint8_t*)(p))[1] = (d)>>16; \ | |
213 ((uint8_t*)(p))[0] = (d)>>24; \ | |
214 } while(0) | |
727 | 215 #endif |
232
9845a508ffbd
add AV_WB/WL for lswriting, similar to AV_RB/RL (also increment version)
alex
parents:
231
diff
changeset
|
216 |
727 | 217 #ifndef AV_RL32 |
768 | 218 # define AV_RL32(x) \ |
219 ((((const uint8_t*)(x))[3] << 24) | \ | |
220 (((const uint8_t*)(x))[2] << 16) | \ | |
221 (((const uint8_t*)(x))[1] << 8) | \ | |
222 ((const uint8_t*)(x))[0]) | |
727 | 223 #endif |
224 #ifndef AV_WL32 | |
768 | 225 # define AV_WL32(p, d) do { \ |
226 ((uint8_t*)(p))[0] = (d); \ | |
227 ((uint8_t*)(p))[1] = (d)>>8; \ | |
228 ((uint8_t*)(p))[2] = (d)>>16; \ | |
229 ((uint8_t*)(p))[3] = (d)>>24; \ | |
230 } while(0) | |
727 | 231 #endif |
152
5b211d03227b
Move BE_*/LE_*/ST*/LD* macros to a common place. Some further
reimar
parents:
diff
changeset
|
232 |
727 | 233 #ifndef AV_RB64 |
768 | 234 # define AV_RB64(x) \ |
235 (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ | |
236 ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ | |
237 ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ | |
238 ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ | |
239 ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ | |
240 ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ | |
241 ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ | |
242 (uint64_t)((const uint8_t*)(x))[7]) | |
727 | 243 #endif |
244 #ifndef AV_WB64 | |
768 | 245 # define AV_WB64(p, d) do { \ |
246 ((uint8_t*)(p))[7] = (d); \ | |
247 ((uint8_t*)(p))[6] = (d)>>8; \ | |
248 ((uint8_t*)(p))[5] = (d)>>16; \ | |
249 ((uint8_t*)(p))[4] = (d)>>24; \ | |
250 ((uint8_t*)(p))[3] = (d)>>32; \ | |
251 ((uint8_t*)(p))[2] = (d)>>40; \ | |
252 ((uint8_t*)(p))[1] = (d)>>48; \ | |
253 ((uint8_t*)(p))[0] = (d)>>56; \ | |
254 } while(0) | |
727 | 255 #endif |
335 | 256 |
727 | 257 #ifndef AV_RL64 |
768 | 258 # define AV_RL64(x) \ |
259 (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ | |
260 ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ | |
261 ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ | |
262 ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ | |
263 ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ | |
264 ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ | |
265 ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ | |
266 (uint64_t)((const uint8_t*)(x))[0]) | |
727 | 267 #endif |
268 #ifndef AV_WL64 | |
768 | 269 # define AV_WL64(p, d) do { \ |
270 ((uint8_t*)(p))[0] = (d); \ | |
271 ((uint8_t*)(p))[1] = (d)>>8; \ | |
272 ((uint8_t*)(p))[2] = (d)>>16; \ | |
273 ((uint8_t*)(p))[3] = (d)>>24; \ | |
274 ((uint8_t*)(p))[4] = (d)>>32; \ | |
275 ((uint8_t*)(p))[5] = (d)>>40; \ | |
276 ((uint8_t*)(p))[6] = (d)>>48; \ | |
277 ((uint8_t*)(p))[7] = (d)>>56; \ | |
278 } while(0) | |
727 | 279 #endif |
280 | |
758 | 281 #if HAVE_BIGENDIAN |
727 | 282 # define AV_RN(s, p) AV_RB##s(p) |
283 # define AV_WN(s, p, v) AV_WB##s(p, v) | |
284 #else | |
285 # define AV_RN(s, p) AV_RL##s(p) | |
286 # define AV_WN(s, p, v) AV_WL##s(p, v) | |
287 #endif | |
288 | |
289 #endif /* HAVE_FAST_UNALIGNED */ | |
290 | |
291 #ifndef AV_RN16 | |
292 # define AV_RN16(p) AV_RN(16, p) | |
293 #endif | |
294 | |
295 #ifndef AV_RN32 | |
296 # define AV_RN32(p) AV_RN(32, p) | |
297 #endif | |
298 | |
299 #ifndef AV_RN64 | |
300 # define AV_RN64(p) AV_RN(64, p) | |
301 #endif | |
302 | |
303 #ifndef AV_WN16 | |
304 # define AV_WN16(p, v) AV_WN(16, p, v) | |
305 #endif | |
306 | |
307 #ifndef AV_WN32 | |
308 # define AV_WN32(p, v) AV_WN(32, p, v) | |
309 #endif | |
310 | |
311 #ifndef AV_WN64 | |
312 # define AV_WN64(p, v) AV_WN(64, p, v) | |
313 #endif | |
314 | |
758 | 315 #if HAVE_BIGENDIAN |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
316 # 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
|
317 # define AV_WB(s, p, v) AV_WN##s(p, v) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
318 # define AV_RL(s, p) bswap_##s(AV_RN##s(p)) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
319 # define AV_WL(s, p, v) AV_WN##s(p, bswap_##s(v)) |
727 | 320 #else |
767
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
321 # define AV_RB(s, p) bswap_##s(AV_RN##s(p)) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
322 # define AV_WB(s, p, v) AV_WN##s(p, bswap_##s(v)) |
231275ff8012
intreadwrite: ensure arch-specific versions are always used if defined
mru
parents:
766
diff
changeset
|
323 # 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
|
324 # define AV_WL(s, p, v) AV_WN##s(p, v) |
727 | 325 #endif |
326 | |
327 #define AV_RB8(x) (((const uint8_t*)(x))[0]) | |
328 #define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) | |
329 | |
330 #define AV_RL8(x) AV_RB8(x) | |
331 #define AV_WL8(p, d) AV_WB8(p, d) | |
332 | |
333 #ifndef AV_RB16 | |
334 # define AV_RB16(p) AV_RB(16, p) | |
335 #endif | |
336 #ifndef AV_WB16 | |
337 # define AV_WB16(p, v) AV_WB(16, p, v) | |
338 #endif | |
339 | |
340 #ifndef AV_RL16 | |
341 # define AV_RL16(p) AV_RL(16, p) | |
342 #endif | |
343 #ifndef AV_WL16 | |
344 # define AV_WL16(p, v) AV_WL(16, p, v) | |
345 #endif | |
346 | |
347 #ifndef AV_RB32 | |
348 # define AV_RB32(p) AV_RB(32, p) | |
349 #endif | |
350 #ifndef AV_WB32 | |
351 # define AV_WB32(p, v) AV_WB(32, p, v) | |
352 #endif | |
353 | |
354 #ifndef AV_RL32 | |
355 # define AV_RL32(p) AV_RL(32, p) | |
356 #endif | |
357 #ifndef AV_WL32 | |
358 # define AV_WL32(p, v) AV_WL(32, p, v) | |
359 #endif | |
360 | |
361 #ifndef AV_RB64 | |
362 # define AV_RB64(p) AV_RB(64, p) | |
363 #endif | |
364 #ifndef AV_WB64 | |
365 # define AV_WB64(p, v) AV_WB(64, p, v) | |
366 #endif | |
367 | |
368 #ifndef AV_RL64 | |
369 # define AV_RL64(p) AV_RL(64, p) | |
370 #endif | |
371 #ifndef AV_WL64 | |
372 # define AV_WL64(p, v) AV_WL(64, p, v) | |
373 #endif | |
524 | 374 |
766 | 375 #ifndef AV_RB24 |
768 | 376 # define AV_RB24(x) \ |
377 ((((const uint8_t*)(x))[0] << 16) | \ | |
378 (((const uint8_t*)(x))[1] << 8) | \ | |
379 ((const uint8_t*)(x))[2]) | |
766 | 380 #endif |
381 #ifndef AV_WB24 | |
768 | 382 # define AV_WB24(p, d) do { \ |
383 ((uint8_t*)(p))[2] = (d); \ | |
384 ((uint8_t*)(p))[1] = (d)>>8; \ | |
385 ((uint8_t*)(p))[0] = (d)>>16; \ | |
386 } while(0) | |
766 | 387 #endif |
524 | 388 |
766 | 389 #ifndef AV_RL24 |
768 | 390 # define AV_RL24(x) \ |
391 ((((const uint8_t*)(x))[2] << 16) | \ | |
392 (((const uint8_t*)(x))[1] << 8) | \ | |
393 ((const uint8_t*)(x))[0]) | |
766 | 394 #endif |
395 #ifndef AV_WL24 | |
768 | 396 # define AV_WL24(p, d) do { \ |
397 ((uint8_t*)(p))[0] = (d); \ | |
398 ((uint8_t*)(p))[1] = (d)>>8; \ | |
399 ((uint8_t*)(p))[2] = (d)>>16; \ | |
400 } while(0) | |
766 | 401 #endif |
335 | 402 |
813
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
403 /* 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
|
404 * 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
|
405 * 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
|
406 * afterwards. |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
407 */ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
408 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
409 #define AV_COPY(n, d, s) (*(uint##n##_t*)(d) = *(const uint##n##_t*)(s)) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
410 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
411 #ifndef AV_COPY64 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
412 # 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
|
413 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
414 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
415 #ifndef AV_COPY128 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
416 # define AV_COPY128(d, s) \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
417 do { \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
418 AV_COPY64(d, s); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
419 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
|
420 } while(0) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
421 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
422 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
423 #define AV_SWAP(n, a, b) FFSWAP(uint##n##_t, *(uint##n##_t*)(a), *(uint##n##_t*)(b)) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
424 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
425 #ifndef AV_SWAP64 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
426 # 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
|
427 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
428 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
429 #define AV_ZERO(n, d) (*(uint##n##_t*)(d) = 0) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
430 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
431 #ifndef AV_ZERO64 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
432 # 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
|
433 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
434 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
435 #ifndef AV_ZERO128 |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
436 # define AV_ZERO128(d) \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
437 do { \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
438 AV_ZERO64(d); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
439 AV_ZERO64((char*)(d)+8); \ |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
440 } while(0) |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
441 #endif |
7c4f89909560
Add macros for 64- and 128-bit write-combining optimization to intreadwrite.h.
astrange
parents:
810
diff
changeset
|
442 |
567 | 443 #endif /* AVUTIL_INTREADWRITE_H */ |