1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11
12 /* \file mem_ops.h
13 * \brief Provides portable memory access primatives
14 *
15 * This function provides portable primatives for getting and setting of
16 * signed and unsigned integers in 16, 24, and 32 bit sizes. The operations
17 * can be performed on unaligned data regardless of hardware support for
18 * unaligned accesses.
19 *
20 * The type used to pass the integral values may be changed by defining
21 * MEM_VALUE_T with the appropriate type. The type given must be an integral
22 * numeric type.
23 *
24 * The actual functions instantiated have the MEM_VALUE_T type name pasted
25 * on to the symbol name. This allows the developer to instantiate these
26 * operations for multiple types within the same translation unit. This is
27 * of somewhat questionable utility, but the capability exists nonetheless.
28 * Users not making use of this functionality should call the functions
29 * without the type name appended, and the preprocessor will take care of
30 * it.
31 *
32 * NOTE: This code is not supported on platforms where char > 1 octet ATM.
33 */
34
35 #ifndef MAU_T
36 /* Minimum Access Unit for this target */
37 #define MAU_T unsigned char
38 #endif
39
40 #ifndef MEM_VALUE_T
41 #define MEM_VALUE_T int
42 #endif
43
44 #undef MEM_VALUE_T_SZ_BITS
45 #define MEM_VALUE_T_SZ_BITS (sizeof(MEM_VALUE_T) << 3)
46
47 #undef mem_ops_wrap_symbol
48 #define mem_ops_wrap_symbol(fn) mem_ops_wrap_symbol2(fn, MEM_VALUE_T)
49 #undef mem_ops_wrap_symbol2
50 #define mem_ops_wrap_symbol2(fn,typ) mem_ops_wrap_symbol3(fn,typ)
51 #undef mem_ops_wrap_symbol3
52 #define mem_ops_wrap_symbol3(fn,typ) fn##_as_##typ
53
54 /*
55 * Include aligned access routines
56 */
57 #define INCLUDED_BY_MEM_OPS_H
58 #include "mem_ops_aligned.h"
59 #undef INCLUDED_BY_MEM_OPS_H
60
61 #undef mem_get_be16
62 #define mem_get_be16 mem_ops_wrap_symbol(mem_get_be16)
mem_get_be16(const void * vmem)63 static unsigned MEM_VALUE_T mem_get_be16(const void *vmem)
64 {
65 unsigned MEM_VALUE_T val;
66 const MAU_T *mem = (const MAU_T *)vmem;
67
68 val = mem[0] << 8;
69 val |= mem[1];
70 return val;
71 }
72
73 #undef mem_get_be24
74 #define mem_get_be24 mem_ops_wrap_symbol(mem_get_be24)
mem_get_be24(const void * vmem)75 static unsigned MEM_VALUE_T mem_get_be24(const void *vmem)
76 {
77 unsigned MEM_VALUE_T val;
78 const MAU_T *mem = (const MAU_T *)vmem;
79
80 val = mem[0] << 16;
81 val |= mem[1] << 8;
82 val |= mem[2];
83 return val;
84 }
85
86 #undef mem_get_be32
87 #define mem_get_be32 mem_ops_wrap_symbol(mem_get_be32)
mem_get_be32(const void * vmem)88 static unsigned MEM_VALUE_T mem_get_be32(const void *vmem)
89 {
90 unsigned MEM_VALUE_T val;
91 const MAU_T *mem = (const MAU_T *)vmem;
92
93 val = mem[0] << 24;
94 val |= mem[1] << 16;
95 val |= mem[2] << 8;
96 val |= mem[3];
97 return val;
98 }
99
100 #undef mem_get_le16
101 #define mem_get_le16 mem_ops_wrap_symbol(mem_get_le16)
mem_get_le16(const void * vmem)102 static unsigned MEM_VALUE_T mem_get_le16(const void *vmem)
103 {
104 unsigned MEM_VALUE_T val;
105 const MAU_T *mem = (const MAU_T *)vmem;
106
107 val = mem[1] << 8;
108 val |= mem[0];
109 return val;
110 }
111
112 #undef mem_get_le24
113 #define mem_get_le24 mem_ops_wrap_symbol(mem_get_le24)
mem_get_le24(const void * vmem)114 static unsigned MEM_VALUE_T mem_get_le24(const void *vmem)
115 {
116 unsigned MEM_VALUE_T val;
117 const MAU_T *mem = (const MAU_T *)vmem;
118
119 val = mem[2] << 16;
120 val |= mem[1] << 8;
121 val |= mem[0];
122 return val;
123 }
124
125 #undef mem_get_le32
126 #define mem_get_le32 mem_ops_wrap_symbol(mem_get_le32)
mem_get_le32(const void * vmem)127 static unsigned MEM_VALUE_T mem_get_le32(const void *vmem)
128 {
129 unsigned MEM_VALUE_T val;
130 const MAU_T *mem = (const MAU_T *)vmem;
131
132 val = mem[3] << 24;
133 val |= mem[2] << 16;
134 val |= mem[1] << 8;
135 val |= mem[0];
136 return val;
137 }
138
139 #define mem_get_s_generic(end,sz) \
140 static signed MEM_VALUE_T mem_get_s##end##sz(const void *vmem) {\
141 const MAU_T *mem = (const MAU_T*)vmem;\
142 signed MEM_VALUE_T val = mem_get_##end##sz(mem);\
143 return (val << (MEM_VALUE_T_SZ_BITS - sz)) >> (MEM_VALUE_T_SZ_BITS - sz);\
144 }
145
146 #undef mem_get_sbe16
147 #define mem_get_sbe16 mem_ops_wrap_symbol(mem_get_sbe16)
148 mem_get_s_generic(be, 16);
149
150 #undef mem_get_sbe24
151 #define mem_get_sbe24 mem_ops_wrap_symbol(mem_get_sbe24)
152 mem_get_s_generic(be, 24);
153
154 #undef mem_get_sbe32
155 #define mem_get_sbe32 mem_ops_wrap_symbol(mem_get_sbe32)
156 mem_get_s_generic(be, 32);
157
158 #undef mem_get_sle16
159 #define mem_get_sle16 mem_ops_wrap_symbol(mem_get_sle16)
160 mem_get_s_generic(le, 16);
161
162 #undef mem_get_sle24
163 #define mem_get_sle24 mem_ops_wrap_symbol(mem_get_sle24)
164 mem_get_s_generic(le, 24);
165
166 #undef mem_get_sle32
167 #define mem_get_sle32 mem_ops_wrap_symbol(mem_get_sle32)
168 mem_get_s_generic(le, 32);
169
170 #undef mem_put_be16
171 #define mem_put_be16 mem_ops_wrap_symbol(mem_put_be16)
mem_put_be16(void * vmem,MEM_VALUE_T val)172 static void mem_put_be16(void *vmem, MEM_VALUE_T val)
173 {
174 MAU_T *mem = (MAU_T *)vmem;
175
176 mem[0] = (val >> 8) & 0xff;
177 mem[1] = (val >> 0) & 0xff;
178 }
179
180 #undef mem_put_be24
181 #define mem_put_be24 mem_ops_wrap_symbol(mem_put_be24)
mem_put_be24(void * vmem,MEM_VALUE_T val)182 static void mem_put_be24(void *vmem, MEM_VALUE_T val)
183 {
184 MAU_T *mem = (MAU_T *)vmem;
185
186 mem[0] = (val >> 16) & 0xff;
187 mem[1] = (val >> 8) & 0xff;
188 mem[2] = (val >> 0) & 0xff;
189 }
190
191 #undef mem_put_be32
192 #define mem_put_be32 mem_ops_wrap_symbol(mem_put_be32)
mem_put_be32(void * vmem,MEM_VALUE_T val)193 static void mem_put_be32(void *vmem, MEM_VALUE_T val)
194 {
195 MAU_T *mem = (MAU_T *)vmem;
196
197 mem[0] = (val >> 24) & 0xff;
198 mem[1] = (val >> 16) & 0xff;
199 mem[2] = (val >> 8) & 0xff;
200 mem[3] = (val >> 0) & 0xff;
201 }
202
203 #undef mem_put_le16
204 #define mem_put_le16 mem_ops_wrap_symbol(mem_put_le16)
mem_put_le16(void * vmem,MEM_VALUE_T val)205 static void mem_put_le16(void *vmem, MEM_VALUE_T val)
206 {
207 MAU_T *mem = (MAU_T *)vmem;
208
209 mem[0] = (val >> 0) & 0xff;
210 mem[1] = (val >> 8) & 0xff;
211 }
212
213 #undef mem_put_le24
214 #define mem_put_le24 mem_ops_wrap_symbol(mem_put_le24)
mem_put_le24(void * vmem,MEM_VALUE_T val)215 static void mem_put_le24(void *vmem, MEM_VALUE_T val)
216 {
217 MAU_T *mem = (MAU_T *)vmem;
218
219 mem[0] = (val >> 0) & 0xff;
220 mem[1] = (val >> 8) & 0xff;
221 mem[2] = (val >> 16) & 0xff;
222 }
223
224 #undef mem_put_le32
225 #define mem_put_le32 mem_ops_wrap_symbol(mem_put_le32)
mem_put_le32(void * vmem,MEM_VALUE_T val)226 static void mem_put_le32(void *vmem, MEM_VALUE_T val)
227 {
228 MAU_T *mem = (MAU_T *)vmem;
229
230 mem[0] = (val >> 0) & 0xff;
231 mem[1] = (val >> 8) & 0xff;
232 mem[2] = (val >> 16) & 0xff;
233 mem[3] = (val >> 24) & 0xff;
234 }
235