ZenLib
Utils.h
Go to the documentation of this file.
1 /* Copyright (c) MediaArea.net SARL. All Rights Reserved.
2  *
3  * Use of this source code is governed by a zlib-style license that can
4  * be found in the License.txt file in the root of the source tree.
5  */
6 
7 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8 //
9 // Integer and float manipulation
10 //
11 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
12 
13 //---------------------------------------------------------------------------
14 #ifndef ZenUtilsH
15 #define ZenUtilsH
16 //---------------------------------------------------------------------------
17 
18 //---------------------------------------------------------------------------
19 #include "ZenLib/int128u.h"
20 //---------------------------------------------------------------------------
21 
22 namespace ZenLib
23 {
24 
25 //***************************************************************************
26 // Integer transformations
27 //***************************************************************************
28 
29 //---------------------------------------------------------------------------
30 //Little Endians
31 int8s LittleEndian2int8s (const char* List);
32 int8u LittleEndian2int8u (const char* List);
33 int16s LittleEndian2int16s (const char* List);
34 int16u LittleEndian2int16u (const char* List);
35 int32s LittleEndian2int24s (const char* List);
36 int32u LittleEndian2int24u (const char* List);
37 int32s LittleEndian2int32s (const char* List);
38 int32u LittleEndian2int32u (const char* List);
39 #if (MAXTYPE_INT >= 64)
40 int64s LittleEndian2int40s (const char* List);
41 int64u LittleEndian2int40u (const char* List);
42 int64s LittleEndian2int48s (const char* List);
43 int64u LittleEndian2int48u (const char* List);
44 int64s LittleEndian2int56s (const char* List);
45 int64u LittleEndian2int56u (const char* List);
46 int64s LittleEndian2int64s (const char* List);
47 int64u LittleEndian2int64u (const char* List);
48 int128u LittleEndian2int128u (const char* List);
49 #endif
50 float32 LittleEndian2float16 (const char* List);
51 float32 LittleEndian2float32 (const char* List);
52 float64 LittleEndian2float64 (const char* List);
53 float80 LittleEndian2float80 (const char* List);
54 
55 void int8s2LittleEndian (char* List, int8s Value);
56 void int8u2LittleEndian (char* List, int8u Value);
57 void int16s2LittleEndian (char* List, int16s Value);
58 void int16u2LittleEndian (char* List, int16u Value);
59 void int24s2LittleEndian (char* List, int32s Value);
60 void int24u2LittleEndian (char* List, int32u Value);
61 void int32s2LittleEndian (char* List, int32s Value);
62 void int32u2LittleEndian (char* List, int32u Value);
63 #if (MAXTYPE_INT >= 64)
64 void int40s2LittleEndian (char* List, int64s Value);
65 void int40u2LittleEndian (char* List, int64u Value);
66 void int48s2LittleEndian (char* List, int64s Value);
67 void int48u2LittleEndian (char* List, int64u Value);
68 void int56s2LittleEndian (char* List, int64s Value);
69 void int56u2LittleEndian (char* List, int64u Value);
70 void int64s2LittleEndian (char* List, int64s Value);
71 void int64u2LittleEndian (char* List, int64u Value);
72 void int128u2LittleEndian (char* List, int128u Value);
73 #endif
74 void float162LittleEndian (char* List, float32 Value);
75 void float322LittleEndian (char* List, float32 Value);
76 void float642LittleEndian (char* List, float64 Value);
77 void float802LittleEndian (char* List, float80 Value);
78 
79 inline int8s LittleEndian2int8s (const int8u* List) {return LittleEndian2int8s ((const char*)List);}
80 inline int8u LittleEndian2int8u (const int8u* List) {return LittleEndian2int8u ((const char*)List);}
81 inline int16s LittleEndian2int16s (const int8u* List) {return LittleEndian2int16s ((const char*)List);}
82 inline int16u LittleEndian2int16u (const int8u* List) {return LittleEndian2int16u ((const char*)List);}
83 inline int32s LittleEndian2int24s (const int8u* List) {return LittleEndian2int24s ((const char*)List);}
84 inline int32u LittleEndian2int24u (const int8u* List) {return LittleEndian2int24u ((const char*)List);}
85 inline int32s LittleEndian2int32s (const int8u* List) {return LittleEndian2int32s ((const char*)List);}
86 inline int32u LittleEndian2int32u (const int8u* List) {return LittleEndian2int32u ((const char*)List);}
87 #if (MAXTYPE_INT >= 64)
88 inline int64s LittleEndian2int40s (const int8u* List) {return LittleEndian2int40s ((const char*)List);}
89 inline int64u LittleEndian2int40u (const int8u* List) {return LittleEndian2int40u ((const char*)List);}
90 inline int64s LittleEndian2int48s (const int8u* List) {return LittleEndian2int48s ((const char*)List);}
91 inline int64u LittleEndian2int48u (const int8u* List) {return LittleEndian2int48u ((const char*)List);}
92 inline int64s LittleEndian2int56s (const int8u* List) {return LittleEndian2int56s ((const char*)List);}
93 inline int64u LittleEndian2int56u (const int8u* List) {return LittleEndian2int56u ((const char*)List);}
94 inline int64s LittleEndian2int64s (const int8u* List) {return LittleEndian2int64s ((const char*)List);}
95 inline int64u LittleEndian2int64u (const int8u* List) {return LittleEndian2int64u ((const char*)List);}
96 inline int128u LittleEndian2int128u (const int8u* List) {return LittleEndian2int64u ((const char*)List);}
97 #endif
98 inline float32 LittleEndian2float16 (const int8u* List) {return LittleEndian2float16 ((const char*)List);}
99 inline float32 LittleEndian2float32 (const int8u* List) {return LittleEndian2float32 ((const char*)List);}
100 inline float64 LittleEndian2float64 (const int8u* List) {return LittleEndian2float64 ((const char*)List);}
101 inline float80 LittleEndian2float80 (const int8u* List) {return LittleEndian2float80 ((const char*)List);}
102 
103 inline void int8s2LittleEndian (int8u* List, int8s Value) {return int8s2LittleEndian ((char*)List, Value);}
104 inline void int8u2LittleEndian (int8u* List, int8u Value) {return int8u2LittleEndian ((char*)List, Value);}
105 inline void int16s2LittleEndian (int8u* List, int16s Value) {return int16s2LittleEndian ((char*)List, Value);}
106 inline void int16u2LittleEndian (int8u* List, int16u Value) {return int16u2LittleEndian ((char*)List, Value);}
107 inline void int24s2LittleEndian (int8u* List, int32s Value) {return int24s2LittleEndian ((char*)List, Value);}
108 inline void int24u2LittleEndian (int8u* List, int32u Value) {return int24u2LittleEndian ((char*)List, Value);}
109 inline void int32s2LittleEndian (int8u* List, int32s Value) {return int32s2LittleEndian ((char*)List, Value);}
110 inline void int32u2LittleEndian (int8u* List, int32u Value) {return int32u2LittleEndian ((char*)List, Value);}
111 #if (MAXTYPE_INT >= 64)
112 inline void int40s2LittleEndian (int8u* List, int64s Value) {return int40s2LittleEndian ((char*)List, Value);}
113 inline void int40u2LittleEndian (int8u* List, int64u Value) {return int40u2LittleEndian ((char*)List, Value);}
114 inline void int48s2LittleEndian (int8u* List, int64s Value) {return int48s2LittleEndian ((char*)List, Value);}
115 inline void int48u2LittleEndian (int8u* List, int64u Value) {return int48u2LittleEndian ((char*)List, Value);}
116 inline void int56s2LittleEndian (int8u* List, int64s Value) {return int56s2LittleEndian ((char*)List, Value);}
117 inline void int56u2LittleEndian (int8u* List, int64u Value) {return int56u2LittleEndian ((char*)List, Value);}
118 inline void int64s2LittleEndian (int8u* List, int64s Value) {return int64s2LittleEndian ((char*)List, Value);}
119 inline void int64u2LittleEndian (int8u* List, int64u Value) {return int64u2LittleEndian ((char*)List, Value);}
120 inline void int128u2LittleEndian (int8u* List, int128u Value) {return int128u2LittleEndian ((char*)List, Value);}
121 #endif
122 inline void float162LittleEndian (int8u* List, float32 Value) {return float162LittleEndian ((char*)List, Value);}
123 inline void float322LittleEndian (int8u* List, float32 Value) {return float322LittleEndian ((char*)List, Value);}
124 inline void float642LittleEndian (int8u* List, float64 Value) {return float642LittleEndian ((char*)List, Value);}
125 inline void float802LittleEndian (int8u* List, float80 Value) {return float802LittleEndian ((char*)List, Value);}
126 
127 //---------------------------------------------------------------------------
128 //Big Endians
129 int8s BigEndian2int8s (const char* List);
130 int8u BigEndian2int8u (const char* List);
131 int16s BigEndian2int16s (const char* List);
132 int16u BigEndian2int16u (const char* List);
133 int32s BigEndian2int24s (const char* List);
134 int32u BigEndian2int24u (const char* List);
135 int32s BigEndian2int32s (const char* List);
136 int32u BigEndian2int32u (const char* List);
137 #if (MAXTYPE_INT >= 64)
138 int64s BigEndian2int40s (const char* List);
139 int64u BigEndian2int40u (const char* List);
140 int64s BigEndian2int48s (const char* List);
141 int64u BigEndian2int48u (const char* List);
142 int64s BigEndian2int56s (const char* List);
143 int64u BigEndian2int56u (const char* List);
144 int64s BigEndian2int64s (const char* List);
145 int64u BigEndian2int64u (const char* List);
146 int128u BigEndian2int128u (const char* List);
147 #endif
148 float32 BigEndian2float16 (const char* List);
149 float32 BigEndian2float32 (const char* List);
150 float64 BigEndian2float64 (const char* List);
151 float80 BigEndian2float80 (const char* List);
152 
153 void int8s2BigEndian (char* List, int8s Value);
154 void int8u2BigEndian (char* List, int8u Value);
155 void int16s2BigEndian (char* List, int16s Value);
156 void int16u2BigEndian (char* List, int16u Value);
157 void int24s2BigEndian (char* List, int32s Value);
158 void int24u2BigEndian (char* List, int32u Value);
159 void int32s2BigEndian (char* List, int32s Value);
160 void int32u2BigEndian (char* List, int32u Value);
161 #if (MAXTYPE_INT >= 64)
162 void int40s2BigEndian (char* List, int64s Value);
163 void int40u2BigEndian (char* List, int64u Value);
164 void int48s2BigEndian (char* List, int64s Value);
165 void int48u2BigEndian (char* List, int64u Value);
166 void int56s2BigEndian (char* List, int64s Value);
167 void int56u2BigEndian (char* List, int64u Value);
168 void int64s2BigEndian (char* List, int64s Value);
169 void int64u2BigEndian (char* List, int64u Value);
170 void int128u2BigEndian (char* List, int128u Value);
171 #endif
172 void float162BigEndian (char* List, float32 Value);
173 void float322BigEndian (char* List, float32 Value);
174 void float642BigEndian (char* List, float64 Value);
175 void float802BigEndian (char* List, float80 Value);
176 
177 inline int8s BigEndian2int8s (const int8u* List) {return BigEndian2int8s ((const char*)List);}
178 inline int8u BigEndian2int8u (const int8u* List) {return BigEndian2int8u ((const char*)List);}
179 inline int16s BigEndian2int16s (const int8u* List) {return BigEndian2int16s ((const char*)List);}
180 inline int16u BigEndian2int16u (const int8u* List) {return BigEndian2int16u ((const char*)List);}
181 inline int32s BigEndian2int32s (const int8u* List) {return BigEndian2int32s ((const char*)List);}
182 inline int32u BigEndian2int24u (const int8u* List) {return BigEndian2int24u ((const char*)List);}
183 inline int32s BigEndian2int24s (const int8u* List) {return BigEndian2int24s ((const char*)List);}
184 inline int32u BigEndian2int32u (const int8u* List) {return BigEndian2int32u ((const char*)List);}
185 #if (MAXTYPE_INT >= 64)
186 inline int64s BigEndian2int40s (const int8u* List) {return BigEndian2int40s ((const char*)List);}
187 inline int64u BigEndian2int40u (const int8u* List) {return BigEndian2int40u ((const char*)List);}
188 inline int64s BigEndian2int48s (const int8u* List) {return BigEndian2int48s ((const char*)List);}
189 inline int64u BigEndian2int48u (const int8u* List) {return BigEndian2int48u ((const char*)List);}
190 inline int64s BigEndian2int56s (const int8u* List) {return BigEndian2int56s ((const char*)List);}
191 inline int64u BigEndian2int56u (const int8u* List) {return BigEndian2int56u ((const char*)List);}
192 inline int64s BigEndian2int64s (const int8u* List) {return BigEndian2int64s ((const char*)List);}
193 inline int64u BigEndian2int64u (const int8u* List) {return BigEndian2int64u ((const char*)List);}
194 inline int128u BigEndian2int128u (const int8u* List) {return BigEndian2int128u ((const char*)List);}
195 #endif
196 inline float32 BigEndian2float16 (const int8u* List) {return BigEndian2float16 ((const char*)List);}
197 inline float32 BigEndian2float32 (const int8u* List) {return BigEndian2float32 ((const char*)List);}
198 inline float64 BigEndian2float64 (const int8u* List) {return BigEndian2float64 ((const char*)List);}
199 inline float80 BigEndian2float80 (const int8u* List) {return BigEndian2float80 ((const char*)List);}
200 
201 inline void int8s2BigEndian (int8u* List, int8s Value) {return int8s2BigEndian ((char*)List, Value);}
202 inline void int8u2BigEndian (int8u* List, int8u Value) {return int8u2BigEndian ((char*)List, Value);}
203 inline void int16s2BigEndian (int8u* List, int16s Value) {return int16s2BigEndian ((char*)List, Value);}
204 inline void int16u2BigEndian (int8u* List, int16u Value) {return int16u2BigEndian ((char*)List, Value);}
205 inline void int24s2BigEndian (int8u* List, int32s Value) {return int24s2BigEndian ((char*)List, Value);}
206 inline void int24u2BigEndian (int8u* List, int32u Value) {return int24u2BigEndian ((char*)List, Value);}
207 inline void int32s2BigEndian (int8u* List, int32s Value) {return int32s2BigEndian ((char*)List, Value);}
208 inline void int32u2BigEndian (int8u* List, int32u Value) {return int32u2BigEndian ((char*)List, Value);}
209 #if (MAXTYPE_INT >= 64)
210 inline void int40s2BigEndian (int8u* List, int64s Value) {return int40s2BigEndian ((char*)List, Value);}
211 inline void int40u2BigEndian (int8u* List, int64u Value) {return int40u2BigEndian ((char*)List, Value);}
212 inline void int48s2BigEndian (int8u* List, int64s Value) {return int48s2BigEndian ((char*)List, Value);}
213 inline void int48u2BigEndian (int8u* List, int64u Value) {return int48u2BigEndian ((char*)List, Value);}
214 inline void int56s2BigEndian (int8u* List, int64s Value) {return int56s2BigEndian ((char*)List, Value);}
215 inline void int56u2BigEndian (int8u* List, int64u Value) {return int56u2BigEndian ((char*)List, Value);}
216 inline void int64s2BigEndian (int8u* List, int64s Value) {return int64s2BigEndian ((char*)List, Value);}
217 inline void int64u2BigEndian (int8u* List, int64u Value) {return int64u2BigEndian ((char*)List, Value);}
218 inline void int128u2BigEndian (int8u* List, int128u Value) {return int128u2BigEndian ((char*)List, Value);}
219 #endif
220 inline void float162BigEndian (int8u* List, float32 Value) {return float162BigEndian ((char*)List, Value);}
221 inline void float322BigEndian (int8u* List, float32 Value) {return float322BigEndian ((char*)List, Value);}
222 inline void float642BigEndian (int8u* List, float64 Value) {return float642BigEndian ((char*)List, Value);}
223 inline void float802BigEndian (int8u* List, float80 Value) {return float802BigEndian ((char*)List, Value);}
224 
225 //---------------------------------------------------------------------------
226 // int32 - int64
227 int64s int32s_int64s ( int32s High, int32u Low);
228 int64u int32u_int64u ( int32u High, int32u Low);
229 void int32s_int64s (int64s &BigInt, int32s High, int32u Low);
230 void int32u_int64u (int64s &BigInt, int32u High, int32u Low);
231 void int64s_int32s (int64s BigInt, int32s &High, int32u &Low);
232 void int64u_int32u (int64u BigInt, int32u &High, int32u &Low);
233 
234 //---------------------------------------------------------------------------
235 // Floats and ints
236 int32s float32_int32s (float32 F, bool Rounded=true);
237 int64s float32_int64s (float32 F, bool Rounded=true);
238 int32s float64_int32s (float64 F, bool Rounded=true);
239 int64s float64_int64s (float64 F, bool Rounded=true);
240 
241 // These functions are used because MSVC6 isn't able to convert an unsigned int64 to a floating-point value, and I couldn't think of a cleaner way to handle it.
242 #if defined(_MSC_VER) && _MSC_VER<=1200
243  inline float32 int64u_float32 (int64u v) {return static_cast<float32>(static_cast<int64s>(v>>1))*2.0f + static_cast<float32>(static_cast<int64s>(v & 1));}
244  inline float64 int64u_float64 (int64u v) {return static_cast<float64>(static_cast<int64s>(v>>1))*2.0f + static_cast<float32>(static_cast<int64s>(v & 1));}
245 #else
246  inline float32 int64u_float32 (int64u v) {return (float32)v;}
247  inline float64 int64u_float64 (int64u v) {return (float64)v;}
248 #endif // defined(_MSC_VER) && _MSC_VER<=1200
249 
250 //---------------------------------------------------------------------------
251 // CC (often used in all containers to identify a stream
252 inline int64u CC8(const char* C) {return BigEndian2int64u(C);}
253 inline int64u CC7(const char* C) {return BigEndian2int56u(C);}
254 inline int64u CC6(const char* C) {return BigEndian2int48u(C);}
255 inline int64u CC5(const char* C) {return BigEndian2int40u(C);}
256 inline int32u CC4(const char* C) {return BigEndian2int32u(C);}
257 inline int32u CC3(const char* C) {return BigEndian2int24u(C);}
258 inline int16u CC2(const char* C) {return BigEndian2int16u(C);}
259 inline int8u CC1(const char* C) {return BigEndian2int8u (C);}
260 inline int64u CC8(const int8u* C) {return BigEndian2int64u(C);}
261 inline int64u CC7(const int8u* C) {return BigEndian2int56u(C);}
262 inline int64u CC6(const int8u* C) {return BigEndian2int48u(C);}
263 inline int64u CC5(const int8u* C) {return BigEndian2int40u(C);}
264 inline int32u CC4(const int8u* C) {return BigEndian2int32u(C);}
265 inline int32u CC3(const int8u* C) {return BigEndian2int24u(C);}
266 inline int16u CC2(const int8u* C) {return BigEndian2int16u(C);}
267 inline int8u CC1(const int8u* C) {return BigEndian2int8u (C);}
268 
269 //---------------------------------------------------------------------------
270 // turn a numeric literal into a hex constant
271 // (avoids problems with leading zeroes)
272 // 8-bit constants max value 0x11111111, always fits in unsigned long
273 #define HEX__(n) 0x##n##LU
274 
275 // 8-bit conversion function
276 #define B8__(x) ((x&0x0000000FLU)?0x01:0) \
277  +((x&0x000000F0LU)?0x02:0) \
278  +((x&0x00000F00LU)?0x04:0) \
279  +((x&0x0000F000LU)?0x08:0) \
280  +((x&0x000F0000LU)?0x10:0) \
281  +((x&0x00F00000LU)?0x20:0) \
282  +((x&0x0F000000LU)?0x40:0) \
283  +((x&0xF0000000LU)?0x80:0)
284 
285 // for upto 8-bit binary constants
286 #define B8(d) ((int8u)B8__(HEX__(d)))
287 
288 // for upto 16-bit binary constants, MSB first
289 #define B16(dmsb, dlsb) (((int16u)B8(dmsb)<<8) \
290  + ((int16u)B8(dlsb)<<0))
291 
292 // for upto 32-bit binary constants, MSB first
293 #define B32(dmsb, db2, db3, dlsb) (((int32u)B8(dmsb)<<24) \
294  + ((int32u)B8( db2)<<16) \
295  + ((int32u)B8( db3)<< 8) \
296  + ((int32u)B8(dlsb)<< 0))
297 
298 } //namespace ZenLib
299 #endif
ZenLib::float64_int32s
int32s float64_int32s(float64 F, bool Rounded=true)
ZenLib::LittleEndian2int32s
int32s LittleEndian2int32s(const char *List)
ZenLib::LittleEndian2int32u
int32u LittleEndian2int32u(const char *List)
ZenLib::int32u2LittleEndian
void int32u2LittleEndian(char *List, int32u Value)
ZenLib::LittleEndian2float16
float32 LittleEndian2float16(const char *List)
ZenLib::int8s2LittleEndian
void int8s2LittleEndian(char *List, int8s Value)
ZenLib::BigEndian2int16s
int16s BigEndian2int16s(const char *List)
ZenLib::int24s2LittleEndian
void int24s2LittleEndian(char *List, int32s Value)
ZenLib::int32s_int64s
int64s int32s_int64s(int32s High, int32u Low)
ZenLib::BigEndian2float32
float32 BigEndian2float32(const char *List)
ZenLib::LittleEndian2int24u
int32u LittleEndian2int24u(const char *List)
ZenLib::int8u2BigEndian
void int8u2BigEndian(char *List, int8u Value)
ZenLib::float162LittleEndian
void float162LittleEndian(char *List, float32 Value)
ZenLib::int32s2BigEndian
void int32s2BigEndian(char *List, int32s Value)
ZenLib::LittleEndian2int16u
int16u LittleEndian2int16u(const char *List)
ZenLib::BigEndian2int16u
int16u BigEndian2int16u(const char *List)
ZenLib::int64s_int32s
void int64s_int32s(int64s BigInt, int32s &High, int32u &Low)
ZenLib::BigEndian2int32u
int32u BigEndian2int32u(const char *List)
ZenLib::LittleEndian2int8u
int8u LittleEndian2int8u(const char *List)
ZenLib::int64u_int32u
void int64u_int32u(int64u BigInt, int32u &High, int32u &Low)
int128u.h
ZenLib::BigEndian2int8s
int8s BigEndian2int8s(const char *List)
ZenLib::LittleEndian2float64
float64 LittleEndian2float64(const char *List)
ZenLib::BigEndian2float16
float32 BigEndian2float16(const char *List)
ZenLib::BigEndian2int8u
int8u BigEndian2int8u(const char *List)
ZenLib::CC8
int64u CC8(const char *C)
Definition: Utils.h:252
ZenLib::float642BigEndian
void float642BigEndian(char *List, float64 Value)
ZenLib::int8u2LittleEndian
void int8u2LittleEndian(char *List, int8u Value)
ZenLib::float322BigEndian
void float322BigEndian(char *List, float32 Value)
ZenLib::LittleEndian2int8s
int8s LittleEndian2int8s(const char *List)
ZenLib::float802LittleEndian
void float802LittleEndian(char *List, float80 Value)
ZenLib::float642LittleEndian
void float642LittleEndian(char *List, float64 Value)
ZenLib::CC5
int64u CC5(const char *C)
Definition: Utils.h:255
ZenLib::BigEndian2int24u
int32u BigEndian2int24u(const char *List)
ZenLib::int24s2BigEndian
void int24s2BigEndian(char *List, int32s Value)
ZenLib::LittleEndian2float32
float32 LittleEndian2float32(const char *List)
ZenLib::LittleEndian2int24s
int32s LittleEndian2int24s(const char *List)
ZenLib::BigEndian2float80
float80 BigEndian2float80(const char *List)
ZenLib::int8s2BigEndian
void int8s2BigEndian(char *List, int8s Value)
ZenLib
Definition: BitStream.h:23
ZenLib::LittleEndian2float80
float80 LittleEndian2float80(const char *List)
ZenLib::CC7
int64u CC7(const char *C)
Definition: Utils.h:253
ZenLib::int64u_float64
float64 int64u_float64(int64u v)
Definition: Utils.h:247
ZenLib::float32_int64s
int64s float32_int64s(float32 F, bool Rounded=true)
ZenLib::int16u2LittleEndian
void int16u2LittleEndian(char *List, int16u Value)
ZenLib::CC3
int32u CC3(const char *C)
Definition: Utils.h:257
ZenLib::float802BigEndian
void float802BigEndian(char *List, float80 Value)
ZenLib::BigEndian2int32s
int32s BigEndian2int32s(const char *List)
ZenLib::int16s2LittleEndian
void int16s2LittleEndian(char *List, int16s Value)
ZenLib::int128u
uint128 int128u
Definition: int128u.h:179
ZenLib::int24u2LittleEndian
void int24u2LittleEndian(char *List, int32u Value)
ZenLib::float64_int64s
int64s float64_int64s(float64 F, bool Rounded=true)
ZenLib::BigEndian2float64
float64 BigEndian2float64(const char *List)
ZenLib::int24u2BigEndian
void int24u2BigEndian(char *List, int32u Value)
ZenLib::LittleEndian2int16s
int16s LittleEndian2int16s(const char *List)
ZenLib::int64u_float32
float32 int64u_float32(int64u v)
Definition: Utils.h:246
ZenLib::float32_int32s
int32s float32_int32s(float32 F, bool Rounded=true)
ZenLib::float322LittleEndian
void float322LittleEndian(char *List, float32 Value)
ZenLib::CC4
int32u CC4(const char *C)
Definition: Utils.h:256
ZenLib::int32u2BigEndian
void int32u2BigEndian(char *List, int32u Value)
ZenLib::CC6
int64u CC6(const char *C)
Definition: Utils.h:254
ZenLib::int16s2BigEndian
void int16s2BigEndian(char *List, int16s Value)
ZenLib::CC1
int8u CC1(const char *C)
Definition: Utils.h:259
ZenLib::int32s2LittleEndian
void int32s2LittleEndian(char *List, int32s Value)
ZenLib::CC2
int16u CC2(const char *C)
Definition: Utils.h:258
ZenLib::BigEndian2int24s
int32s BigEndian2int24s(const char *List)
ZenLib::int16u2BigEndian
void int16u2BigEndian(char *List, int16u Value)
ZenLib::int32u_int64u
int64u int32u_int64u(int32u High, int32u Low)
ZenLib::float162BigEndian
void float162BigEndian(char *List, float32 Value)