1 /*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #ifndef SkEndian_DEFINED
9 #define SkEndian_DEFINED
10
11 #include "SkTypes.h"
12
13 /** \file SkEndian.h
14
15 Macros and helper functions for handling 16 and 32 bit values in
16 big and little endian formats.
17 */
18
19 #if defined(SK_CPU_LENDIAN) && defined(SK_CPU_BENDIAN)
20 #error "can't have both LENDIAN and BENDIAN defined"
21 #endif
22
23 #if !defined(SK_CPU_LENDIAN) && !defined(SK_CPU_BENDIAN)
24 #error "need either LENDIAN or BENDIAN defined"
25 #endif
26
27 /** Swap the two bytes in the low 16bits of the parameters.
28 e.g. 0x1234 -> 0x3412
29 */
SkEndianSwap16(uint16_t value)30 static inline uint16_t SkEndianSwap16(uint16_t value) {
31 return static_cast<uint16_t>((value >> 8) | (value << 8));
32 }
33
34 template<uint16_t N> struct SkTEndianSwap16 {
35 static const uint16_t value = static_cast<uint16_t>((N >> 8) | ((N & 0xFF) << 8));
36 };
37
38 /** Vector version of SkEndianSwap16(), which swaps the
39 low two bytes of each value in the array.
40 */
SkEndianSwap16s(uint16_t array[],int count)41 static inline void SkEndianSwap16s(uint16_t array[], int count) {
42 SkASSERT(count == 0 || array != nullptr);
43
44 while (--count >= 0) {
45 *array = SkEndianSwap16(*array);
46 array += 1;
47 }
48 }
49
50 /** Reverse all 4 bytes in a 32bit value.
51 e.g. 0x12345678 -> 0x78563412
52 */
SkEndianSwap32(uint32_t value)53 static inline uint32_t SkEndianSwap32(uint32_t value) {
54 return ((value & 0xFF) << 24) |
55 ((value & 0xFF00) << 8) |
56 ((value & 0xFF0000) >> 8) |
57 (value >> 24);
58 }
59
60 template<uint32_t N> struct SkTEndianSwap32 {
61 static const uint32_t value = ((N & 0xFF) << 24) |
62 ((N & 0xFF00) << 8) |
63 ((N & 0xFF0000) >> 8) |
64 (N >> 24);
65 };
66
67 /** Vector version of SkEndianSwap32(), which swaps the
68 bytes of each value in the array.
69 */
SkEndianSwap32s(uint32_t array[],int count)70 static inline void SkEndianSwap32s(uint32_t array[], int count) {
71 SkASSERT(count == 0 || array != nullptr);
72
73 while (--count >= 0) {
74 *array = SkEndianSwap32(*array);
75 array += 1;
76 }
77 }
78
79 /** Reverse all 8 bytes in a 64bit value.
80 e.g. 0x1122334455667788 -> 0x8877665544332211
81 */
SkEndianSwap64(uint64_t value)82 static inline uint64_t SkEndianSwap64(uint64_t value) {
83 return (((value & 0x00000000000000FFULL) << (8*7)) |
84 ((value & 0x000000000000FF00ULL) << (8*5)) |
85 ((value & 0x0000000000FF0000ULL) << (8*3)) |
86 ((value & 0x00000000FF000000ULL) << (8*1)) |
87 ((value & 0x000000FF00000000ULL) >> (8*1)) |
88 ((value & 0x0000FF0000000000ULL) >> (8*3)) |
89 ((value & 0x00FF000000000000ULL) >> (8*5)) |
90 ((value) >> (8*7)));
91 }
92 template<uint64_t N> struct SkTEndianSwap64 {
93 static const uint64_t value = (((N & 0x00000000000000FFULL) << (8*7)) |
94 ((N & 0x000000000000FF00ULL) << (8*5)) |
95 ((N & 0x0000000000FF0000ULL) << (8*3)) |
96 ((N & 0x00000000FF000000ULL) << (8*1)) |
97 ((N & 0x000000FF00000000ULL) >> (8*1)) |
98 ((N & 0x0000FF0000000000ULL) >> (8*3)) |
99 ((N & 0x00FF000000000000ULL) >> (8*5)) |
100 ((N) >> (8*7)));
101 };
102
103 /** Vector version of SkEndianSwap64(), which swaps the
104 bytes of each value in the array.
105 */
SkEndianSwap64s(uint64_t array[],int count)106 static inline void SkEndianSwap64s(uint64_t array[], int count) {
107 SkASSERT(count == 0 || array != nullptr);
108
109 while (--count >= 0) {
110 *array = SkEndianSwap64(*array);
111 array += 1;
112 }
113 }
114
115 #ifdef SK_CPU_LENDIAN
116 #define SkEndian_SwapBE16(n) SkEndianSwap16(n)
117 #define SkEndian_SwapBE32(n) SkEndianSwap32(n)
118 #define SkEndian_SwapBE64(n) SkEndianSwap64(n)
119 #define SkEndian_SwapLE16(n) (n)
120 #define SkEndian_SwapLE32(n) (n)
121 #define SkEndian_SwapLE64(n) (n)
122
123 #define SkTEndian_SwapBE16(n) SkTEndianSwap16<n>::value
124 #define SkTEndian_SwapBE32(n) SkTEndianSwap32<n>::value
125 #define SkTEndian_SwapBE64(n) SkTEndianSwap64<n>::value
126 #define SkTEndian_SwapLE16(n) (n)
127 #define SkTEndian_SwapLE32(n) (n)
128 #define SkTEndian_SwapLE64(n) (n)
129 #else // SK_CPU_BENDIAN
130 #define SkEndian_SwapBE16(n) (n)
131 #define SkEndian_SwapBE32(n) (n)
132 #define SkEndian_SwapBE64(n) (n)
133 #define SkEndian_SwapLE16(n) SkEndianSwap16(n)
134 #define SkEndian_SwapLE32(n) SkEndianSwap32(n)
135 #define SkEndian_SwapLE64(n) SkEndianSwap64(n)
136
137 #define SkTEndian_SwapBE16(n) (n)
138 #define SkTEndian_SwapBE32(n) (n)
139 #define SkTEndian_SwapBE64(n) (n)
140 #define SkTEndian_SwapLE16(n) SkTEndianSwap16<n>::value
141 #define SkTEndian_SwapLE32(n) SkTEndianSwap32<n>::value
142 #define SkTEndian_SwapLE64(n) SkTEndianSwap64<n>::value
143 #endif
144
145 // When a bytestream is embedded in a 32-bit word, how far we need to
146 // shift the word to extract each byte from the low 8 bits by anding with 0xff.
147 #ifdef SK_CPU_LENDIAN
148 #define SkEndian_Byte0Shift 0
149 #define SkEndian_Byte1Shift 8
150 #define SkEndian_Byte2Shift 16
151 #define SkEndian_Byte3Shift 24
152 #else // SK_CPU_BENDIAN
153 #define SkEndian_Byte0Shift 24
154 #define SkEndian_Byte1Shift 16
155 #define SkEndian_Byte2Shift 8
156 #define SkEndian_Byte3Shift 0
157 #endif
158
159
160 #if defined(SK_UINT8_BITFIELD_LENDIAN) && defined(SK_UINT8_BITFIELD_BENDIAN)
161 #error "can't have both bitfield LENDIAN and BENDIAN defined"
162 #endif
163
164 #if !defined(SK_UINT8_BITFIELD_LENDIAN) && !defined(SK_UINT8_BITFIELD_BENDIAN)
165 #ifdef SK_CPU_LENDIAN
166 #define SK_UINT8_BITFIELD_LENDIAN
167 #else
168 #define SK_UINT8_BITFIELD_BENDIAN
169 #endif
170 #endif
171
172 #ifdef SK_UINT8_BITFIELD_LENDIAN
173 #define SK_UINT8_BITFIELD(f0, f1, f2, f3, f4, f5, f6, f7) \
174 SK_OT_BYTE f0 : 1; \
175 SK_OT_BYTE f1 : 1; \
176 SK_OT_BYTE f2 : 1; \
177 SK_OT_BYTE f3 : 1; \
178 SK_OT_BYTE f4 : 1; \
179 SK_OT_BYTE f5 : 1; \
180 SK_OT_BYTE f6 : 1; \
181 SK_OT_BYTE f7 : 1;
182 #else
183 #define SK_UINT8_BITFIELD(f0, f1, f2, f3, f4, f5, f6, f7) \
184 SK_OT_BYTE f7 : 1; \
185 SK_OT_BYTE f6 : 1; \
186 SK_OT_BYTE f5 : 1; \
187 SK_OT_BYTE f4 : 1; \
188 SK_OT_BYTE f3 : 1; \
189 SK_OT_BYTE f2 : 1; \
190 SK_OT_BYTE f1 : 1; \
191 SK_OT_BYTE f0 : 1;
192 #endif
193
194 #endif
195