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