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
13 * \brief Provides portable memory access primitives
14 *
15 * This function provides portable primitives 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)
63static 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)
75static 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)
88static 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)
102static 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)
114static 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)
127static 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)
148mem_get_s_generic(be, 16);
149
150#undef  mem_get_sbe24
151#define mem_get_sbe24 mem_ops_wrap_symbol(mem_get_sbe24)
152mem_get_s_generic(be, 24);
153
154#undef  mem_get_sbe32
155#define mem_get_sbe32 mem_ops_wrap_symbol(mem_get_sbe32)
156mem_get_s_generic(be, 32);
157
158#undef  mem_get_sle16
159#define mem_get_sle16 mem_ops_wrap_symbol(mem_get_sle16)
160mem_get_s_generic(le, 16);
161
162#undef  mem_get_sle24
163#define mem_get_sle24 mem_ops_wrap_symbol(mem_get_sle24)
164mem_get_s_generic(le, 24);
165
166#undef  mem_get_sle32
167#define mem_get_sle32 mem_ops_wrap_symbol(mem_get_sle32)
168mem_get_s_generic(le, 32);
169
170#undef  mem_put_be16
171#define mem_put_be16 mem_ops_wrap_symbol(mem_put_be16)
172static 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)
182static 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)
193static 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)
205static 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)
215static 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)
226static 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