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
22namespace ZenLib
23{
24
25//***************************************************************************
26// Integer transformations
27//***************************************************************************
28
29//---------------------------------------------------------------------------
30//Little Endians
31int8s LittleEndian2int8s (const char* List);
32int8u LittleEndian2int8u (const char* List);
33int16s LittleEndian2int16s (const char* List);
34int16u LittleEndian2int16u (const char* List);
35int32s LittleEndian2int24s (const char* List);
36int32u LittleEndian2int24u (const char* List);
37int32s LittleEndian2int32s (const char* List);
38int32u LittleEndian2int32u (const char* List);
39#if (MAXTYPE_INT >= 64)
40int64s LittleEndian2int40s (const char* List);
41int64u LittleEndian2int40u (const char* List);
42int64s LittleEndian2int48s (const char* List);
43int64u LittleEndian2int48u (const char* List);
44int64s LittleEndian2int56s (const char* List);
45int64u LittleEndian2int56u (const char* List);
46int64s LittleEndian2int64s (const char* List);
47int64u LittleEndian2int64u (const char* List);
48int128u LittleEndian2int128u (const char* List);
49#endif
50float32 LittleEndian2float16 (const char* List);
51float32 LittleEndian2float32 (const char* List);
52float64 LittleEndian2float64 (const char* List);
53float80 LittleEndian2float80 (const char* List);
54
55void int8s2LittleEndian (char* List, int8s Value);
56void int8u2LittleEndian (char* List, int8u Value);
57void int16s2LittleEndian (char* List, int16s Value);
58void int16u2LittleEndian (char* List, int16u Value);
59void int24s2LittleEndian (char* List, int32s Value);
60void int24u2LittleEndian (char* List, int32u Value);
61void int32s2LittleEndian (char* List, int32s Value);
62void int32u2LittleEndian (char* List, int32u Value);
63#if (MAXTYPE_INT >= 64)
64void int40s2LittleEndian (char* List, int64s Value);
65void int40u2LittleEndian (char* List, int64u Value);
66void int48s2LittleEndian (char* List, int64s Value);
67void int48u2LittleEndian (char* List, int64u Value);
68void int56s2LittleEndian (char* List, int64s Value);
69void int56u2LittleEndian (char* List, int64u Value);
70void int64s2LittleEndian (char* List, int64s Value);
71void int64u2LittleEndian (char* List, int64u Value);
72void int128u2LittleEndian (char* List, int128u Value);
73#endif
74void float162LittleEndian (char* List, float32 Value);
75void float322LittleEndian (char* List, float32 Value);
76void float642LittleEndian (char* List, float64 Value);
77void float802LittleEndian (char* List, float80 Value);
78
79inline int8s LittleEndian2int8s (const int8u* List) {return LittleEndian2int8s ((const char*)List);}
80inline int8u LittleEndian2int8u (const int8u* List) {return LittleEndian2int8u ((const char*)List);}
81inline int16s LittleEndian2int16s (const int8u* List) {return LittleEndian2int16s ((const char*)List);}
82inline int16u LittleEndian2int16u (const int8u* List) {return LittleEndian2int16u ((const char*)List);}
83inline int32s LittleEndian2int24s (const int8u* List) {return LittleEndian2int24s ((const char*)List);}
84inline int32u LittleEndian2int24u (const int8u* List) {return LittleEndian2int24u ((const char*)List);}
85inline int32s LittleEndian2int32s (const int8u* List) {return LittleEndian2int32s ((const char*)List);}
86inline int32u LittleEndian2int32u (const int8u* List) {return LittleEndian2int32u ((const char*)List);}
87#if (MAXTYPE_INT >= 64)
88inline int64s LittleEndian2int40s (const int8u* List) {return LittleEndian2int40s ((const char*)List);}
89inline int64u LittleEndian2int40u (const int8u* List) {return LittleEndian2int40u ((const char*)List);}
90inline int64s LittleEndian2int48s (const int8u* List) {return LittleEndian2int48s ((const char*)List);}
91inline int64u LittleEndian2int48u (const int8u* List) {return LittleEndian2int48u ((const char*)List);}
92inline int64s LittleEndian2int56s (const int8u* List) {return LittleEndian2int56s ((const char*)List);}
93inline int64u LittleEndian2int56u (const int8u* List) {return LittleEndian2int56u ((const char*)List);}
94inline int64s LittleEndian2int64s (const int8u* List) {return LittleEndian2int64s ((const char*)List);}
95inline int64u LittleEndian2int64u (const int8u* List) {return LittleEndian2int64u ((const char*)List);}
96inline int128u LittleEndian2int128u (const int8u* List) {return LittleEndian2int64u ((const char*)List);}
97#endif
98inline float32 LittleEndian2float16 (const int8u* List) {return LittleEndian2float16 ((const char*)List);}
99inline float32 LittleEndian2float32 (const int8u* List) {return LittleEndian2float32 ((const char*)List);}
100inline float64 LittleEndian2float64 (const int8u* List) {return LittleEndian2float64 ((const char*)List);}
101inline float80 LittleEndian2float80 (const int8u* List) {return LittleEndian2float80 ((const char*)List);}
102
103inline void int8s2LittleEndian (int8u* List, int8s Value) {return int8s2LittleEndian ((char*)List, Value);}
104inline void int8u2LittleEndian (int8u* List, int8u Value) {return int8u2LittleEndian ((char*)List, Value);}
105inline void int16s2LittleEndian (int8u* List, int16s Value) {return int16s2LittleEndian ((char*)List, Value);}
106inline void int16u2LittleEndian (int8u* List, int16u Value) {return int16u2LittleEndian ((char*)List, Value);}
107inline void int24s2LittleEndian (int8u* List, int32s Value) {return int24s2LittleEndian ((char*)List, Value);}
108inline void int24u2LittleEndian (int8u* List, int32u Value) {return int24u2LittleEndian ((char*)List, Value);}
109inline void int32s2LittleEndian (int8u* List, int32s Value) {return int32s2LittleEndian ((char*)List, Value);}
110inline void int32u2LittleEndian (int8u* List, int32u Value) {return int32u2LittleEndian ((char*)List, Value);}
111#if (MAXTYPE_INT >= 64)
112inline void int40s2LittleEndian (int8u* List, int64s Value) {return int40s2LittleEndian ((char*)List, Value);}
113inline void int40u2LittleEndian (int8u* List, int64u Value) {return int40u2LittleEndian ((char*)List, Value);}
114inline void int48s2LittleEndian (int8u* List, int64s Value) {return int48s2LittleEndian ((char*)List, Value);}
115inline void int48u2LittleEndian (int8u* List, int64u Value) {return int48u2LittleEndian ((char*)List, Value);}
116inline void int56s2LittleEndian (int8u* List, int64s Value) {return int56s2LittleEndian ((char*)List, Value);}
117inline void int56u2LittleEndian (int8u* List, int64u Value) {return int56u2LittleEndian ((char*)List, Value);}
118inline void int64s2LittleEndian (int8u* List, int64s Value) {return int64s2LittleEndian ((char*)List, Value);}
119inline void int64u2LittleEndian (int8u* List, int64u Value) {return int64u2LittleEndian ((char*)List, Value);}
120inline void int128u2LittleEndian (int8u* List, int128u Value) {return int128u2LittleEndian ((char*)List, Value);}
121#endif
122inline void float162LittleEndian (int8u* List, float32 Value) {return float162LittleEndian ((char*)List, Value);}
123inline void float322LittleEndian (int8u* List, float32 Value) {return float322LittleEndian ((char*)List, Value);}
124inline void float642LittleEndian (int8u* List, float64 Value) {return float642LittleEndian ((char*)List, Value);}
125inline void float802LittleEndian (int8u* List, float80 Value) {return float802LittleEndian ((char*)List, Value);}
126
127//---------------------------------------------------------------------------
128//Big Endians
129int8s BigEndian2int8s (const char* List);
130int8u BigEndian2int8u (const char* List);
131int16s BigEndian2int16s (const char* List);
132int16u BigEndian2int16u (const char* List);
133int32s BigEndian2int24s (const char* List);
134int32u BigEndian2int24u (const char* List);
135int32s BigEndian2int32s (const char* List);
136int32u BigEndian2int32u (const char* List);
137#if (MAXTYPE_INT >= 64)
138int64s BigEndian2int40s (const char* List);
139int64u BigEndian2int40u (const char* List);
140int64s BigEndian2int48s (const char* List);
141int64u BigEndian2int48u (const char* List);
142int64s BigEndian2int56s (const char* List);
143int64u BigEndian2int56u (const char* List);
144int64s BigEndian2int64s (const char* List);
145int64u BigEndian2int64u (const char* List);
146int128u BigEndian2int128u (const char* List);
147#endif
148float32 BigEndian2float16 (const char* List);
149float32 BigEndian2float32 (const char* List);
150float64 BigEndian2float64 (const char* List);
151float80 BigEndian2float80 (const char* List);
152
153void int8s2BigEndian (char* List, int8s Value);
154void int8u2BigEndian (char* List, int8u Value);
155void int16s2BigEndian (char* List, int16s Value);
156void int16u2BigEndian (char* List, int16u Value);
157void int24s2BigEndian (char* List, int32s Value);
158void int24u2BigEndian (char* List, int32u Value);
159void int32s2BigEndian (char* List, int32s Value);
160void int32u2BigEndian (char* List, int32u Value);
161#if (MAXTYPE_INT >= 64)
162void int40s2BigEndian (char* List, int64s Value);
163void int40u2BigEndian (char* List, int64u Value);
164void int48s2BigEndian (char* List, int64s Value);
165void int48u2BigEndian (char* List, int64u Value);
166void int56s2BigEndian (char* List, int64s Value);
167void int56u2BigEndian (char* List, int64u Value);
168void int64s2BigEndian (char* List, int64s Value);
169void int64u2BigEndian (char* List, int64u Value);
170void int128u2BigEndian (char* List, int128u Value);
171#endif
172void float162BigEndian (char* List, float32 Value);
173void float322BigEndian (char* List, float32 Value);
174void float642BigEndian (char* List, float64 Value);
175void float802BigEndian (char* List, float80 Value);
176
177inline int8s BigEndian2int8s (const int8u* List) {return BigEndian2int8s ((const char*)List);}
178inline int8u BigEndian2int8u (const int8u* List) {return BigEndian2int8u ((const char*)List);}
179inline int16s BigEndian2int16s (const int8u* List) {return BigEndian2int16s ((const char*)List);}
180inline int16u BigEndian2int16u (const int8u* List) {return BigEndian2int16u ((const char*)List);}
181inline int32s BigEndian2int32s (const int8u* List) {return BigEndian2int32s ((const char*)List);}
182inline int32u BigEndian2int24u (const int8u* List) {return BigEndian2int24u ((const char*)List);}
183inline int32s BigEndian2int24s (const int8u* List) {return BigEndian2int24s ((const char*)List);}
184inline int32u BigEndian2int32u (const int8u* List) {return BigEndian2int32u ((const char*)List);}
185#if (MAXTYPE_INT >= 64)
186inline int64s BigEndian2int40s (const int8u* List) {return BigEndian2int40s ((const char*)List);}
187inline int64u BigEndian2int40u (const int8u* List) {return BigEndian2int40u ((const char*)List);}
188inline int64s BigEndian2int48s (const int8u* List) {return BigEndian2int48s ((const char*)List);}
189inline int64u BigEndian2int48u (const int8u* List) {return BigEndian2int48u ((const char*)List);}
190inline int64s BigEndian2int56s (const int8u* List) {return BigEndian2int56s ((const char*)List);}
191inline int64u BigEndian2int56u (const int8u* List) {return BigEndian2int56u ((const char*)List);}
192inline int64s BigEndian2int64s (const int8u* List) {return BigEndian2int64s ((const char*)List);}
193inline int64u BigEndian2int64u (const int8u* List) {return BigEndian2int64u ((const char*)List);}
194inline int128u BigEndian2int128u (const int8u* List) {return BigEndian2int128u ((const char*)List);}
195#endif
196inline float32 BigEndian2float16 (const int8u* List) {return BigEndian2float16 ((const char*)List);}
197inline float32 BigEndian2float32 (const int8u* List) {return BigEndian2float32 ((const char*)List);}
198inline float64 BigEndian2float64 (const int8u* List) {return BigEndian2float64 ((const char*)List);}
199inline float80 BigEndian2float80 (const int8u* List) {return BigEndian2float80 ((const char*)List);}
200
201inline void int8s2BigEndian (int8u* List, int8s Value) {return int8s2BigEndian ((char*)List, Value);}
202inline void int8u2BigEndian (int8u* List, int8u Value) {return int8u2BigEndian ((char*)List, Value);}
203inline void int16s2BigEndian (int8u* List, int16s Value) {return int16s2BigEndian ((char*)List, Value);}
204inline void int16u2BigEndian (int8u* List, int16u Value) {return int16u2BigEndian ((char*)List, Value);}
205inline void int24s2BigEndian (int8u* List, int32s Value) {return int24s2BigEndian ((char*)List, Value);}
206inline void int24u2BigEndian (int8u* List, int32u Value) {return int24u2BigEndian ((char*)List, Value);}
207inline void int32s2BigEndian (int8u* List, int32s Value) {return int32s2BigEndian ((char*)List, Value);}
208inline void int32u2BigEndian (int8u* List, int32u Value) {return int32u2BigEndian ((char*)List, Value);}
209#if (MAXTYPE_INT >= 64)
210inline void int40s2BigEndian (int8u* List, int64s Value) {return int40s2BigEndian ((char*)List, Value);}
211inline void int40u2BigEndian (int8u* List, int64u Value) {return int40u2BigEndian ((char*)List, Value);}
212inline void int48s2BigEndian (int8u* List, int64s Value) {return int48s2BigEndian ((char*)List, Value);}
213inline void int48u2BigEndian (int8u* List, int64u Value) {return int48u2BigEndian ((char*)List, Value);}
214inline void int56s2BigEndian (int8u* List, int64s Value) {return int56s2BigEndian ((char*)List, Value);}
215inline void int56u2BigEndian (int8u* List, int64u Value) {return int56u2BigEndian ((char*)List, Value);}
216inline void int64s2BigEndian (int8u* List, int64s Value) {return int64s2BigEndian ((char*)List, Value);}
217inline void int64u2BigEndian (int8u* List, int64u Value) {return int64u2BigEndian ((char*)List, Value);}
218inline void int128u2BigEndian (int8u* List, int128u Value) {return int128u2BigEndian ((char*)List, Value);}
219#endif
220inline void float162BigEndian (int8u* List, float32 Value) {return float162BigEndian ((char*)List, Value);}
221inline void float322BigEndian (int8u* List, float32 Value) {return float322BigEndian ((char*)List, Value);}
222inline void float642BigEndian (int8u* List, float64 Value) {return float642BigEndian ((char*)List, Value);}
223inline void float802BigEndian (int8u* List, float80 Value) {return float802BigEndian ((char*)List, Value);}
224
225//---------------------------------------------------------------------------
226// int32 - int64
227int64s int32s_int64s ( int32s High, int32u Low);
228int64u int32u_int64u ( int32u High, int32u Low);
229void int32s_int64s (int64s &BigInt, int32s High, int32u Low);
230void int32u_int64u (int64s &BigInt, int32u High, int32u Low);
231void int64s_int32s (int64s BigInt, int32s &High, int32u &Low);
232void int64u_int32u (int64u BigInt, int32u &High, int32u &Low);
233
234//---------------------------------------------------------------------------
235// Floats and ints
236int32s float32_int32s (float32 F, bool Rounded=true);
237int64s float32_int64s (float32 F, bool Rounded=true);
238int32s float64_int32s (float64 F, bool Rounded=true);
239int64s 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
252inline int64u CC8(const char* C) {return BigEndian2int64u(C);}
253inline int64u CC7(const char* C) {return BigEndian2int56u(C);}
254inline int64u CC6(const char* C) {return BigEndian2int48u(C);}
255inline int64u CC5(const char* C) {return BigEndian2int40u(C);}
256inline int32u CC4(const char* C) {return BigEndian2int32u(C);}
257inline int32u CC3(const char* C) {return BigEndian2int24u(C);}
258inline int16u CC2(const char* C) {return BigEndian2int16u(C);}
259inline int8u CC1(const char* C) {return BigEndian2int8u (C);}
260inline int64u CC8(const int8u* C) {return BigEndian2int64u(C);}
261inline int64u CC7(const int8u* C) {return BigEndian2int56u(C);}
262inline int64u CC6(const int8u* C) {return BigEndian2int48u(C);}
263inline int64u CC5(const int8u* C) {return BigEndian2int40u(C);}
264inline int32u CC4(const int8u* C) {return BigEndian2int32u(C);}
265inline int32u CC3(const int8u* C) {return BigEndian2int24u(C);}
266inline int16u CC2(const int8u* C) {return BigEndian2int16u(C);}
267inline 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
Definition int128u.h:35
Definition BitStream.h:24
int16s BigEndian2int16s(const char *List)
int64u CC5(const char *C)
Definition Utils.h:255
uint128 int128u
Definition int128u.h:179
int64s float32_int64s(float32 F, bool Rounded=true)
int32u BigEndian2int32u(const char *List)
int32s BigEndian2int24s(const char *List)
void int8u2BigEndian(char *List, int8u Value)
void int32u2BigEndian(char *List, int32u Value)
int64s int32s_int64s(int32s High, int32u Low)
int16u BigEndian2int16u(const char *List)
void int32s2BigEndian(char *List, int32s Value)
int32s float32_int32s(float32 F, bool Rounded=true)
float80 LittleEndian2float80(const char *List)
int32s float64_int32s(float64 F, bool Rounded=true)
float64 BigEndian2float64(const char *List)
int64u CC7(const char *C)
Definition Utils.h:253
float64 int64u_float64(int64u v)
Definition Utils.h:247
int16s LittleEndian2int16s(const char *List)
void float642BigEndian(char *List, float64 Value)
int64u int32u_int64u(int32u High, int32u Low)
void int24u2BigEndian(char *List, int32u Value)
float32 int64u_float32(int64u v)
Definition Utils.h:246
void float322BigEndian(char *List, float32 Value)
void int16u2LittleEndian(char *List, int16u Value)
int64u CC8(const char *C)
Definition Utils.h:252
void int8u2LittleEndian(char *List, int8u Value)
int8s BigEndian2int8s(const char *List)
int32s BigEndian2int32s(const char *List)
void float322LittleEndian(char *List, float32 Value)
float32 BigEndian2float16(const char *List)
int32u LittleEndian2int24u(const char *List)
void int64s_int32s(int64s BigInt, int32s &High, int32u &Low)
int32u LittleEndian2int32u(const char *List)
float64 LittleEndian2float64(const char *List)
void int8s2BigEndian(char *List, int8s Value)
void int32s2LittleEndian(char *List, int32s Value)
int32u CC3(const char *C)
Definition Utils.h:257
void int32u2LittleEndian(char *List, int32u Value)
void int24s2LittleEndian(char *List, int32s Value)
int8s LittleEndian2int8s(const char *List)
int8u BigEndian2int8u(const char *List)
void int16s2BigEndian(char *List, int16s Value)
int8u LittleEndian2int8u(const char *List)
float32 BigEndian2float32(const char *List)
float32 LittleEndian2float16(const char *List)
int32u BigEndian2int24u(const char *List)
int32s LittleEndian2int32s(const char *List)
void int16s2LittleEndian(char *List, int16s Value)
void int64u_int32u(int64u BigInt, int32u &High, int32u &Low)
int64u CC6(const char *C)
Definition Utils.h:254
float32 LittleEndian2float32(const char *List)
void float642LittleEndian(char *List, float64 Value)
int16u CC2(const char *C)
Definition Utils.h:258
void float162BigEndian(char *List, float32 Value)
int32s LittleEndian2int24s(const char *List)
float80 BigEndian2float80(const char *List)
int16u LittleEndian2int16u(const char *List)
void int8s2LittleEndian(char *List, int8s Value)
void int16u2BigEndian(char *List, int16u Value)
void float162LittleEndian(char *List, float32 Value)
void float802BigEndian(char *List, float80 Value)
void float802LittleEndian(char *List, float80 Value)
void int24s2BigEndian(char *List, int32s Value)
int8u CC1(const char *C)
Definition Utils.h:259
int32u CC4(const char *C)
Definition Utils.h:256
void int24u2LittleEndian(char *List, int32u Value)
int64s float64_int64s(float64 F, bool Rounded=true)