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 #include "ZenLib/PreComp.h"
9 #ifdef __BORLANDC__
10 #pragma hdrstop
11 #endif
12 //---------------------------------------------------------------------------
13
14 //---------------------------------------------------------------------------
15 #include "ZenLib/Conf_Internal.h"
16 //---------------------------------------------------------------------------
17
18 //---------------------------------------------------------------------------
19 #include "ZenLib/Utils.h"
20 #include <cmath>
21 #include <complex>
22 //---------------------------------------------------------------------------
23
24 namespace ZenLib
25 {
26
27 //***************************************************************************
28 // Transformations - Little Endian to something
29 //***************************************************************************
30
31 //---------------------------------------------------------------------------
32 // Little Endian - 8 bits
LittleEndian2int8s(const char * Liste)33 int8s LittleEndian2int8s (const char* Liste)
34 {
35 return (int8s)Liste[0];
36 }
37
LittleEndian2int8u(const char * Liste)38 int8u LittleEndian2int8u (const char* Liste)
39 {
40 return (int8u)Liste[0];
41 }
42
43 //---------------------------------------------------------------------------
44 // Little Endian - 16 bits
LittleEndian2int16s(const char * Liste)45 int16s LittleEndian2int16s (const char* Liste)
46 {
47 int16s Retour= (int8s)Liste[1];
48 Retour=(Retour<<8)|(int8u)Liste[0];
49 return Retour;
50 }
51
LittleEndian2int16u(const char * Liste)52 int16u LittleEndian2int16u (const char* Liste)
53 {
54 int16u Retour= (int8u)Liste[1];
55 Retour=(Retour<<8)|(int8u)Liste[0];
56 return Retour;
57 }
58
59 //---------------------------------------------------------------------------
60 // Little Endian - 24 bits
LittleEndian2int24s(const char * Liste)61 int32s LittleEndian2int24s (const char* Liste)
62 {
63 int32s Retour= (int8s)Liste[2];
64 Retour=(Retour<<8)|(int8u)Liste[1];
65 Retour=(Retour<<8)|(int8u)Liste[0];
66 return Retour;
67 }
68
LittleEndian2int24u(const char * Liste)69 int32u LittleEndian2int24u (const char* Liste)
70 {
71 int32u Retour= (int8u)Liste[2];
72 Retour=(Retour<<8)|(int8u)Liste[1];
73 Retour=(Retour<<8)|(int8u)Liste[0];
74 return Retour;
75 }
76
77 //---------------------------------------------------------------------------
78 // Little Endian - 32 bits
LittleEndian2int32s(const char * Liste)79 int32s LittleEndian2int32s (const char* Liste)
80 {
81 int32s Retour= (int8s)Liste[3];
82 Retour=(Retour<<8)|(int8u)Liste[2];
83 Retour=(Retour<<8)|(int8u)Liste[1];
84 Retour=(Retour<<8)|(int8u)Liste[0];
85 return Retour;
86 }
87
LittleEndian2int32u(const char * Liste)88 int32u LittleEndian2int32u (const char* Liste)
89 {
90 int32u Retour= (int8u)Liste[3];
91 Retour=(Retour<<8)|(int8u)Liste[2];
92 Retour=(Retour<<8)|(int8u)Liste[1];
93 Retour=(Retour<<8)|(int8u)Liste[0];
94 return Retour;
95 }
96
97 //---------------------------------------------------------------------------
98 // Little Endian - 40 bits
LittleEndian2int40s(const char * Liste)99 int64s LittleEndian2int40s (const char* Liste)
100 {
101 int64s Retour= (int8u)Liste[4];
102 Retour=(Retour<<8)|(int8u)Liste[3];
103 Retour=(Retour<<8)|(int8u)Liste[2];
104 Retour=(Retour<<8)|(int8u)Liste[1];
105 Retour=(Retour<<8)|(int8u)Liste[0];
106 return Retour;
107 }
108
LittleEndian2int40u(const char * Liste)109 int64u LittleEndian2int40u (const char* Liste)
110 {
111 int64u Retour= (int8u)Liste[4];
112 Retour=(Retour<<8)|(int8u)Liste[3];
113 Retour=(Retour<<8)|(int8u)Liste[2];
114 Retour=(Retour<<8)|(int8u)Liste[1];
115 Retour=(Retour<<8)|(int8u)Liste[0];
116 return Retour;
117 }
118
119 //---------------------------------------------------------------------------
120 // Little Endian - 48 bits
LittleEndian2int48s(const char * Liste)121 int64s LittleEndian2int48s (const char* Liste)
122 {
123 int64s Retour= (int8u)Liste[5];
124 Retour=(Retour<<8)|(int8u)Liste[4];
125 Retour=(Retour<<8)|(int8u)Liste[3];
126 Retour=(Retour<<8)|(int8u)Liste[2];
127 Retour=(Retour<<8)|(int8u)Liste[1];
128 Retour=(Retour<<8)|(int8u)Liste[0];
129 return Retour;
130 }
131
LittleEndian2int48u(const char * Liste)132 int64u LittleEndian2int48u (const char* Liste)
133 {
134 int64u Retour= (int8u)Liste[5];
135 Retour=(Retour<<8)|(int8u)Liste[4];
136 Retour=(Retour<<8)|(int8u)Liste[3];
137 Retour=(Retour<<8)|(int8u)Liste[2];
138 Retour=(Retour<<8)|(int8u)Liste[1];
139 Retour=(Retour<<8)|(int8u)Liste[0];
140 return Retour;
141 }
142
143 //---------------------------------------------------------------------------
144 // Little Endian - 56 bits
LittleEndian2int56s(const char * Liste)145 int64s LittleEndian2int56s (const char* Liste)
146 {
147 int64s Retour= (int8u)Liste[6];
148 Retour=(Retour<<8)|(int8u)Liste[5];
149 Retour=(Retour<<8)|(int8u)Liste[4];
150 Retour=(Retour<<8)|(int8u)Liste[3];
151 Retour=(Retour<<8)|(int8u)Liste[2];
152 Retour=(Retour<<8)|(int8u)Liste[1];
153 Retour=(Retour<<8)|(int8u)Liste[0];
154 return Retour;
155 }
156
LittleEndian2int56u(const char * Liste)157 int64u LittleEndian2int56u (const char* Liste)
158 {
159 int64u Retour= (int8u)Liste[6];
160 Retour=(Retour<<8)|(int8u)Liste[5];
161 Retour=(Retour<<8)|(int8u)Liste[4];
162 Retour=(Retour<<8)|(int8u)Liste[3];
163 Retour=(Retour<<8)|(int8u)Liste[2];
164 Retour=(Retour<<8)|(int8u)Liste[1];
165 Retour=(Retour<<8)|(int8u)Liste[0];
166 return Retour;
167 }
168
169 //---------------------------------------------------------------------------
170 // Little Endian - 64 bits
LittleEndian2int64s(const char * Liste)171 int64s LittleEndian2int64s (const char* Liste)
172 {
173 int64s Retour= (int8s)Liste[7];
174 Retour=(Retour<<8)|(int8u)Liste[6];
175 Retour=(Retour<<8)|(int8u)Liste[5];
176 Retour=(Retour<<8)|(int8u)Liste[4];
177 Retour=(Retour<<8)|(int8u)Liste[3];
178 Retour=(Retour<<8)|(int8u)Liste[2];
179 Retour=(Retour<<8)|(int8u)Liste[1];
180 Retour=(Retour<<8)|(int8u)Liste[0];
181 return Retour;
182 }
183
LittleEndian2int64u(const char * Liste)184 int64u LittleEndian2int64u (const char* Liste)
185 {
186 int64u Retour= (int8u)Liste[7];
187 Retour=(Retour<<8)|(int8u)Liste[6];
188 Retour=(Retour<<8)|(int8u)Liste[5];
189 Retour=(Retour<<8)|(int8u)Liste[4];
190 Retour=(Retour<<8)|(int8u)Liste[3];
191 Retour=(Retour<<8)|(int8u)Liste[2];
192 Retour=(Retour<<8)|(int8u)Liste[1];
193 Retour=(Retour<<8)|(int8u)Liste[0];
194 return Retour;
195 }
196
197 //---------------------------------------------------------------------------
198 // Little Endian - 128 bits
LittleEndian2int128u(const char * Liste)199 int128u LittleEndian2int128u(const char* Liste)
200 {
201 int128u Retour;
202 Retour.lo=LittleEndian2int64u(Liste);
203 Retour.hi=LittleEndian2int64u(Liste+8);
204 return Retour;
205 }
206
207 //---------------------------------------------------------------------------
208 // Little Endian - float 16 bits
LittleEndian2float16(const char * Liste)209 float32 LittleEndian2float16(const char* Liste)
210 {
211 //sign 1 bit
212 //exponent 5 bit
213 //significand 10 bit
214
215 //Retrieving data
216 int32u Integer=LittleEndian2int32u(Liste);
217
218 //Retrieving elements
219 bool Sign =(Integer&0x8000)?true:false;
220 int32u Exponent=(Integer>>10)&0xFF;
221 int32u Mantissa= Integer&0x03FF;
222
223 //Some computing
224 if (Exponent==0 || Exponent==0xFF)
225 return 0; //These are denormalised numbers, NANs, and other horrible things
226 Exponent-=0x7F; //Bias
227 float64 Answer=(((float64)Mantissa)/8388608+1.0)*std::pow((float64)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
228 if (Sign)
229 Answer=-Answer;
230
231 return (float32)Answer;
232 }
233
234 //---------------------------------------------------------------------------
235 // Little Endian - float 32 bits
LittleEndian2float32(const char * Liste)236 float32 LittleEndian2float32(const char* Liste)
237 {
238 //sign 1 bit
239 //exponent 8 bit
240 //significand 23 bit
241
242 //Retrieving data
243 int32u Integer=LittleEndian2int32u(Liste);
244
245 //Retrieving elements
246 bool Sign =(Integer&0x80000000)?true:false;
247 int32u Exponent=(Integer>>23)&0xFF;
248 int32u Mantissa= Integer&0x007FFFFF;
249
250 //Some computing
251 if (Exponent==0 || Exponent==0xFF)
252 return 0; //These are denormalised numbers, NANs, and other horrible things
253 Exponent-=0x7F; //Bias
254 float64 Answer=(((float64)Mantissa)/8388608+1.0)*std::pow((float64)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
255 if (Sign)
256 Answer=-Answer;
257
258 return (float32)Answer;
259 }
260
261 //---------------------------------------------------------------------------
262 // Little Endian - float 64 bits
LittleEndian2float64(const char * Liste)263 float64 LittleEndian2float64(const char* Liste)
264 {
265 //sign 1 bit
266 //exponent 11 bit
267 //significand 52 bit
268
269 //Retrieving data
270 int64u Integer=LittleEndian2int64u(Liste);
271
272 //Retrieving elements
273 bool Sign =(Integer&0x8000000000000000LL)?true:false;
274 int64u Exponent=(Integer>>52)&0x7FF;
275 int64u Mantissa= Integer&0xFFFFFFFFFFFFFLL;
276
277 //Some computing
278 if (Exponent==0 || Exponent==0x7FF)
279 return 0; //These are denormalised numbers, NANs, and other horrible things
280 Exponent-=0x3FF; //Bias
281 float64 Answer=(((float64)Mantissa)/4503599627370496.0+1.0)*std::pow((float64)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
282 if (Sign)
283 Answer=-Answer;
284
285 return (float64)Answer;
286 }
287
288 //---------------------------------------------------------------------------
289 // Little Endian - float 80 bits
LittleEndian2float80(const char * Liste)290 float80 LittleEndian2float80(const char* Liste)
291 {
292 //sign 1 bit
293 //exponent 15 bit
294 //integer? 1 bit
295 //significand 63 bit
296
297 //Retrieving data
298 int16u Integer1=LittleEndian2int16u(Liste);
299 int64u Integer2=LittleEndian2int64u(Liste+2);
300
301 //Retrieving elements
302 bool Sign =(Integer1&0x8000)?true:false;
303 int16u Exponent= Integer1&0x7FFF;
304 int64u Mantissa= Integer2&0x7FFFFFFFFFFFFFFFLL; //Only 63 bits, 1 most significant bit is explicit
305 //Some computing
306 if (Exponent==0 || Exponent==0x7FFF)
307 return 0; //These are denormalised numbers, NANs, and other horrible things
308 Exponent-=0x3FFF; //Bias
309 float80 Answer=(((float80)Mantissa)/9223372036854775808.0+1.0)*std::pow((float)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
310 if (Sign)
311 Answer=-Answer;
312
313 return (float80)Answer;
314 }
315
316 //***************************************************************************
317 // Transformations - Something to Little Endian
318 //***************************************************************************
319
320 //---------------------------------------------------------------------------
321 // Little Endian - 8 bits
int8s2LittleEndian(char * List,int8s Value)322 void int8s2LittleEndian (char* List, int8s Value)
323 {
324 List[0]=(char)Value;
325 }
326
int8u2LittleEndian(char * List,int8u Value)327 void int8u2LittleEndian (char* List, int8u Value)
328 {
329 List[0]=(char)Value;
330 }
331
332 //---------------------------------------------------------------------------
333 // Little Endian - 16 bits
int16s2LittleEndian(char * List,int16s Value)334 void int16s2LittleEndian (char* List, int16s Value)
335 {
336 List[0]=(char) Value;
337 List[1]=(char)(Value>> 8);
338 }
339
int16u2LittleEndian(char * List,int16u Value)340 void int16u2LittleEndian (char* List, int16u Value)
341 {
342 List[0]=(char) Value;
343 List[1]=(char)(Value>> 8);
344 }
345
346 //---------------------------------------------------------------------------
347 // Little Endian - 24 bits
int24s2LittleEndian(char * List,int32s Value)348 void int24s2LittleEndian (char* List, int32s Value)
349 {
350 List[0]=(char) Value;
351 List[1]=(char)(Value>> 8);
352 List[2]=(char)(Value>>16);
353 }
354
int24u2LittleEndian(char * List,int32u Value)355 void int24u2LittleEndian (char* List, int32u Value)
356 {
357 List[0]=(char) Value;
358 List[1]=(char)(Value>> 8);
359 List[2]=(char)(Value>>16);
360 }
361
362 //---------------------------------------------------------------------------
363 // Little Endian - 32 bits
int32s2LittleEndian(char * List,int32s Value)364 void int32s2LittleEndian (char* List, int32s Value)
365 {
366 List[0]=(char) Value;
367 List[1]=(char)(Value>> 8);
368 List[2]=(char)(Value>>16);
369 List[3]=(char)(Value>>24);
370 }
371
int32u2LittleEndian(char * List,int32u Value)372 void int32u2LittleEndian (char* List, int32u Value)
373 {
374 List[0]=(char) Value;
375 List[1]=(char)(Value>> 8);
376 List[2]=(char)(Value>>16);
377 List[3]=(char)(Value>>24);
378 }
379
380 //---------------------------------------------------------------------------
381 // Little Endian - 40 bits
int40s2LittleEndian(char * List,int64s Value)382 void int40s2LittleEndian (char* List, int64s Value)
383 {
384 List[0]=(char) Value;
385 List[1]=(char)(Value>> 8);
386 List[2]=(char)(Value>>16);
387 List[3]=(char)(Value>>24);
388 List[4]=(char)(Value>>32);
389 }
390
int40u2LittleEndian(char * List,int64u Value)391 void int40u2LittleEndian (char* List, int64u Value)
392 {
393 List[0]=(char) Value;
394 List[1]=(char)(Value>> 8);
395 List[2]=(char)(Value>>16);
396 List[3]=(char)(Value>>24);
397 List[4]=(char)(Value>>32);
398 }
399
400 //---------------------------------------------------------------------------
401 // Little Endian - 48 bits
int48s2LittleEndian(char * List,int64s Value)402 void int48s2LittleEndian (char* List, int64s Value)
403 {
404 List[0]=(char) Value;
405 List[1]=(char)(Value>> 8);
406 List[2]=(char)(Value>>16);
407 List[3]=(char)(Value>>24);
408 List[4]=(char)(Value>>32);
409 List[5]=(char)(Value>>40);
410 }
411
int48u2LittleEndian(char * List,int64u Value)412 void int48u2LittleEndian (char* List, int64u Value)
413 {
414 List[0]=(char) Value;
415 List[1]=(char)(Value>> 8);
416 List[2]=(char)(Value>>16);
417 List[3]=(char)(Value>>24);
418 List[4]=(char)(Value>>32);
419 List[5]=(char)(Value>>40);
420 }
421
422 //---------------------------------------------------------------------------
423 // Little Endian - 56 bits
int56s2LittleEndian(char * List,int64s Value)424 void int56s2LittleEndian (char* List, int64s Value)
425 {
426 List[0]=(char) Value;
427 List[1]=(char)(Value>> 8);
428 List[2]=(char)(Value>>16);
429 List[3]=(char)(Value>>24);
430 List[4]=(char)(Value>>32);
431 List[5]=(char)(Value>>40);
432 List[6]=(char)(Value>>48);
433 }
434
int56u2LittleEndian(char * List,int64u Value)435 void int56u2LittleEndian (char* List, int64u Value)
436 {
437 List[0]=(char) Value;
438 List[1]=(char)(Value>> 8);
439 List[2]=(char)(Value>>16);
440 List[3]=(char)(Value>>24);
441 List[4]=(char)(Value>>32);
442 List[5]=(char)(Value>>40);
443 List[6]=(char)(Value>>48);
444 }
445
446 //---------------------------------------------------------------------------
447 // Little Endian - 64 bits
int64s2LittleEndian(char * List,int64s Value)448 void int64s2LittleEndian (char* List, int64s Value)
449 {
450 List[0]=(char) Value;
451 List[1]=(char)(Value>> 8);
452 List[2]=(char)(Value>>16);
453 List[3]=(char)(Value>>24);
454 List[4]=(char)(Value>>32);
455 List[5]=(char)(Value>>40);
456 List[6]=(char)(Value>>48);
457 List[7]=(char)(Value>>56);
458 }
459
int64u2LittleEndian(char * List,int64u Value)460 void int64u2LittleEndian (char* List, int64u Value)
461 {
462 List[0]=(char) Value;
463 List[1]=(char)(Value>> 8);
464 List[2]=(char)(Value>>16);
465 List[3]=(char)(Value>>24);
466 List[4]=(char)(Value>>32);
467 List[5]=(char)(Value>>40);
468 List[6]=(char)(Value>>48);
469 List[7]=(char)(Value>>56);
470 }
471
472 //---------------------------------------------------------------------------
473 // Little Endian - 128 bits
int128u2LittleEndian(char * List,int128u Value)474 void int128u2LittleEndian(char* List, int128u Value)
475 {
476 int64u2LittleEndian(List+8, Value.lo);
477 int64u2LittleEndian(List , Value.hi);
478 }
479
480 //***************************************************************************
481 // Transformations - Big Endian to something
482 //***************************************************************************
483
484 //---------------------------------------------------------------------------
485 // Big Endian - 8 bits
BigEndian2int8s(const char * Liste)486 int8s BigEndian2int8s (const char* Liste)
487 {
488 return (int8s)Liste[0];
489 }
490
BigEndian2int8u(const char * Liste)491 int8u BigEndian2int8u (const char* Liste)
492 {
493 return (int8u)Liste[0];
494 }
495
496 //---------------------------------------------------------------------------
497 // Big Endian - 16 bits
BigEndian2int16s(const char * Liste)498 int16s BigEndian2int16s (const char* Liste)
499 {
500 int16s Retour= (int8s)Liste[0];
501 Retour=(Retour<<8)|(int8u)Liste[1];
502 return Retour;
503 }
504
BigEndian2int16u(const char * Liste)505 int16u BigEndian2int16u (const char* Liste)
506 {
507 int16u Retour= (int8u)Liste[0];
508 Retour=(Retour<<8)|(int8u)Liste[1];
509 return Retour;
510 }
511
512 //---------------------------------------------------------------------------
513 // Big Endian - 24 bits
BigEndian2int24s(const char * Liste)514 int32s BigEndian2int24s (const char* Liste)
515 {
516 int32s Retour= (int8s)Liste[0];
517 Retour=(Retour<<8)|(int8u)Liste[1];
518 Retour=(Retour<<8)|(int8u)Liste[2];
519 return Retour;
520 }
521
BigEndian2int24u(const char * Liste)522 int32u BigEndian2int24u (const char* Liste)
523 {
524 int32u Retour= (int8u)Liste[0];
525 Retour=(Retour<<8)|(int8u)Liste[1];
526 Retour=(Retour<<8)|(int8u)Liste[2];
527 return Retour;
528 }
529
530 //---------------------------------------------------------------------------
531 // Big Endian - 32 bits
BigEndian2int32s(const char * Liste)532 int32s BigEndian2int32s (const char* Liste)
533 {
534 int32s Retour= (int8s)Liste[0];
535 Retour=(Retour<<8)|(int8u)Liste[1];
536 Retour=(Retour<<8)|(int8u)Liste[2];
537 Retour=(Retour<<8)|(int8u)Liste[3];
538 return Retour;
539 }
540
BigEndian2int32u(const char * Liste)541 int32u BigEndian2int32u (const char* Liste)
542 {
543 int32u Retour= (int8u)Liste[0];
544 Retour=(Retour<<8)|(int8u)Liste[1];
545 Retour=(Retour<<8)|(int8u)Liste[2];
546 Retour=(Retour<<8)|(int8u)Liste[3];
547 return Retour;
548 }
549
550 //---------------------------------------------------------------------------
551 // Big Endian - 40 bits
BigEndian2int40s(const char * Liste)552 int64s BigEndian2int40s (const char* Liste)
553 {
554 int64s Retour= (int8s)Liste[0];
555 Retour=(Retour<<8)|(int8u)Liste[1];
556 Retour=(Retour<<8)|(int8u)Liste[2];
557 Retour=(Retour<<8)|(int8u)Liste[3];
558 Retour=(Retour<<8)|(int8u)Liste[4];
559 return Retour;
560 }
561
BigEndian2int40u(const char * Liste)562 int64u BigEndian2int40u (const char* Liste)
563 {
564 int64u Retour= (int8u)Liste[0];
565 Retour=(Retour<<8)|(int8u)Liste[1];
566 Retour=(Retour<<8)|(int8u)Liste[2];
567 Retour=(Retour<<8)|(int8u)Liste[3];
568 Retour=(Retour<<8)|(int8u)Liste[4];
569 return Retour;
570 }
571
572 //---------------------------------------------------------------------------
573 // Big Endian - 48 bits
BigEndian2int48s(const char * Liste)574 int64s BigEndian2int48s (const char* Liste)
575 {
576 int64s Retour= (int8s)Liste[0];
577 Retour=(Retour<<8)|(int8u)Liste[1];
578 Retour=(Retour<<8)|(int8u)Liste[2];
579 Retour=(Retour<<8)|(int8u)Liste[3];
580 Retour=(Retour<<8)|(int8u)Liste[4];
581 Retour=(Retour<<8)|(int8u)Liste[5];
582 return Retour;
583 }
584
BigEndian2int48u(const char * Liste)585 int64u BigEndian2int48u (const char* Liste)
586 {
587 int64u Retour= (int8u)Liste[0];
588 Retour=(Retour<<8)|(int8u)Liste[1];
589 Retour=(Retour<<8)|(int8u)Liste[2];
590 Retour=(Retour<<8)|(int8u)Liste[3];
591 Retour=(Retour<<8)|(int8u)Liste[4];
592 Retour=(Retour<<8)|(int8u)Liste[5];
593 return Retour;
594 }
595
596 //---------------------------------------------------------------------------
597 // Big Endian - 56 bits
BigEndian2int56s(const char * Liste)598 int64s BigEndian2int56s (const char* Liste)
599 {
600 int64s Retour= (int8s)Liste[0];
601 Retour=(Retour<<8)|(int8u)Liste[1];
602 Retour=(Retour<<8)|(int8u)Liste[2];
603 Retour=(Retour<<8)|(int8u)Liste[3];
604 Retour=(Retour<<8)|(int8u)Liste[4];
605 Retour=(Retour<<8)|(int8u)Liste[5];
606 Retour=(Retour<<8)|(int8u)Liste[6];
607 return Retour;
608 }
609
BigEndian2int56u(const char * Liste)610 int64u BigEndian2int56u (const char* Liste)
611 {
612 int64u Retour= (int8u)Liste[0];
613 Retour=(Retour<<8)|(int8u)Liste[1];
614 Retour=(Retour<<8)|(int8u)Liste[2];
615 Retour=(Retour<<8)|(int8u)Liste[3];
616 Retour=(Retour<<8)|(int8u)Liste[4];
617 Retour=(Retour<<8)|(int8u)Liste[5];
618 Retour=(Retour<<8)|(int8u)Liste[6];
619 return Retour;
620 }
621
622 //---------------------------------------------------------------------------
623 // Big Endian - 64 bits
BigEndian2int64s(const char * Liste)624 int64s BigEndian2int64s (const char* Liste)
625 {
626 int64s Retour=(int8s)Liste[0];
627 Retour=(Retour<<8)|(int8u)Liste[1];
628 Retour=(Retour<<8)|(int8u)Liste[2];
629 Retour=(Retour<<8)|(int8u)Liste[3];
630 Retour=(Retour<<8)|(int8u)Liste[4];
631 Retour=(Retour<<8)|(int8u)Liste[5];
632 Retour=(Retour<<8)|(int8u)Liste[6];
633 Retour=(Retour<<8)|(int8u)Liste[7];
634 return Retour;
635 }
636
BigEndian2int64u(const char * Liste)637 int64u BigEndian2int64u (const char* Liste)
638 {
639 int64u Retour=(int8u)Liste[0];
640 Retour=(Retour<<8)|(int8u)Liste[1];
641 Retour=(Retour<<8)|(int8u)Liste[2];
642 Retour=(Retour<<8)|(int8u)Liste[3];
643 Retour=(Retour<<8)|(int8u)Liste[4];
644 Retour=(Retour<<8)|(int8u)Liste[5];
645 Retour=(Retour<<8)|(int8u)Liste[6];
646 Retour=(Retour<<8)|(int8u)Liste[7];
647 return Retour;
648 }
649
650 //---------------------------------------------------------------------------
651 // Big Endian - 128 bits
BigEndian2int128u(const char * Liste)652 int128u BigEndian2int128u(const char* Liste)
653 {
654 int128u Retour;
655 Retour.hi=BigEndian2int64u(Liste);
656 Retour.lo=BigEndian2int64u(Liste+8);
657 return Retour;
658 }
659
660 //---------------------------------------------------------------------------
661 // Big Endian - float 16 bits
BigEndian2float16(const char * Liste)662 float32 BigEndian2float16(const char* Liste)
663 {
664 //sign 1 bit
665 //exponent 5 bit
666 //significand 10 bit
667
668 //Retrieving data
669 int16u Integer=BigEndian2int16u(Liste);
670
671 //Retrieving elements
672 bool Sign =(Integer&0x8000)?true:false;
673 int32u Exponent=(Integer>>10)&0xFF;
674 int32u Mantissa= Integer&0x03FF;
675
676 //Some computing
677 if (Exponent==0 || Exponent==0xFF)
678 return 0; //These are denormalised numbers, NANs, and other horrible things
679 Exponent-=0x0F; //Bias
680 float64 Answer=(((float64)Mantissa)/8388608+1.0)*std::pow((float64)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
681 if (Sign)
682 Answer=-Answer;
683
684 return (float32)Answer;
685 }
686
687 //---------------------------------------------------------------------------
688 // Big Endian - float 32 bits
BigEndian2float32(const char * Liste)689 float32 BigEndian2float32(const char* Liste)
690 {
691 //sign 1 bit
692 //exponent 8 bit
693 //significand 23 bit
694
695 //Retrieving data
696 int32u Integer=BigEndian2int32u(Liste);
697
698 //Retrieving elements
699 bool Sign =(Integer&0x80000000)?true:false;
700 int32u Exponent=(Integer>>23)&0xFF;
701 int32u Mantissa= Integer&0x007FFFFF;
702
703 //Some computing
704 if (Exponent==0 || Exponent==0xFF)
705 return 0; //These are denormalised numbers, NANs, and other horrible things
706 Exponent-=0x7F; //Bias
707 float64 Answer=(((float64)Mantissa)/8388608+1.0)*std::pow((float64)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
708 if (Sign)
709 Answer=-Answer;
710
711 return (float32)Answer;
712 }
713
714 //---------------------------------------------------------------------------
715 // Big Endian - float 64 bits
BigEndian2float64(const char * Liste)716 float64 BigEndian2float64(const char* Liste)
717 {
718 //sign 1 bit
719 //exponent 11 bit
720 //significand 52 bit
721
722 //Retrieving data
723 int64u Integer=BigEndian2int64u(Liste);
724
725 //Retrieving elements
726 bool Sign =(Integer&0x8000000000000000LL)?true:false;
727 int64u Exponent=(Integer>>52)&0x7FF;
728 int64u Mantissa= Integer&0xFFFFFFFFFFFFFLL;
729
730 //Some computing
731 if (Exponent==0 || Exponent==0x7FF)
732 return 0; //These are denormalised numbers, NANs, and other horrible things
733 Exponent-=0x3FF; //Bias
734 float64 Answer=(((float64)Mantissa)/4503599627370496.0+1.0)*std::pow((float64)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
735 if (Sign)
736 Answer=-Answer;
737
738 return (float64)Answer;
739 }
740
741 //---------------------------------------------------------------------------
742 // Big Endian - float 80 bits
BigEndian2float80(const char * Liste)743 float80 BigEndian2float80(const char* Liste)
744 {
745 //sign 1 bit
746 //exponent 15 bit
747 //integer? 1 bit
748 //significand 63 bit
749
750 //Retrieving data
751 int16u Integer1=BigEndian2int16u(Liste);
752 int64u Integer2=BigEndian2int64u(Liste+2);
753
754 //Retrieving elements
755 bool Sign =(Integer1&0x8000)?true:false;
756 int16u Exponent= Integer1&0x7FFF;
757 int64u Mantissa= Integer2&0x7FFFFFFFFFFFFFFFLL; //Only 63 bits, 1 most significant bit is explicit
758 //Some computing
759 if (Exponent==0 || Exponent==0x7FFF)
760 return 0; //These are denormalised numbers, NANs, and other horrible things
761 Exponent-=0x3FFF; //Bias
762 float80 Answer=(((float80)Mantissa)/9223372036854775808.0+1.0)*std::pow((float)2, (int)Exponent); //(1+Mantissa) * 2^Exponent
763 if (Sign)
764 Answer=-Answer;
765
766 return (float80)Answer;
767 }
768
769 //***************************************************************************
770 // Transformations - Something to Big Endian
771 //***************************************************************************
772
773 //---------------------------------------------------------------------------
774 // Big Endian - 8 bits
int8s2BigEndian(char * List,int8s Value)775 void int8s2BigEndian (char* List, int8s Value)
776 {
777 List[0]=(char)Value;
778 }
779
int8u2BigEndian(char * List,int8u Value)780 void int8u2BigEndian (char* List, int8u Value)
781 {
782 List[0]=(char)Value;
783 }
784
785 //---------------------------------------------------------------------------
786 // Big Endian - 16 bits
int16s2BigEndian(char * List,int16s Value)787 void int16s2BigEndian (char* List, int16s Value)
788 {
789 List[0]=(char)(Value>> 8);
790 List[1]=(char) Value;
791 }
792
int16u2BigEndian(char * List,int16u Value)793 void int16u2BigEndian (char* List, int16u Value)
794 {
795 List[0]=(char)(Value>> 8);
796 List[1]=(char) Value;
797 }
798
799 //---------------------------------------------------------------------------
800 // Big Endian - 24 bits
int24s2BigEndian(char * List,int32s Value)801 void int24s2BigEndian (char* List, int32s Value)
802 {
803 List[0]=(char)(Value>>16);
804 List[1]=(char)(Value>> 8);
805 List[2]=(char) Value;
806 }
807
int24u2BigEndian(char * List,int32u Value)808 void int24u2BigEndian (char* List, int32u Value)
809 {
810 List[0]=(char)(Value>>16);
811 List[1]=(char)(Value>> 8);
812 List[2]=(char) Value;
813 }
814
815 //---------------------------------------------------------------------------
816 // Big Endian - 32 bits
int32s2BigEndian(char * List,int32s Value)817 void int32s2BigEndian (char* List, int32s Value)
818 {
819 List[0]=(char)(Value>>24);
820 List[1]=(char)(Value>>16);
821 List[2]=(char)(Value>> 8);
822 List[3]=(char) Value;
823 }
824
int32u2BigEndian(char * List,int32u Value)825 void int32u2BigEndian (char* List, int32u Value)
826 {
827 List[0]=(char)(Value>>24);
828 List[1]=(char)(Value>>16);
829 List[2]=(char)(Value>> 8);
830 List[3]=(char) Value;
831 }
832
833 //---------------------------------------------------------------------------
834 // Big Endian - 40 bits
int40s2BigEndian(char * List,int64s Value)835 void int40s2BigEndian (char* List, int64s Value)
836 {
837 List[0]=(char)(Value>>32);
838 List[1]=(char)(Value>>24);
839 List[2]=(char)(Value>>16);
840 List[3]=(char)(Value>> 8);
841 List[4]=(char) Value;
842 }
843
int40u2BigEndian(char * List,int64u Value)844 void int40u2BigEndian (char* List, int64u Value)
845 {
846 List[0]=(char)(Value>>32);
847 List[1]=(char)(Value>>24);
848 List[2]=(char)(Value>>16);
849 List[3]=(char)(Value>> 8);
850 List[4]=(char) Value;
851 }
852
853 //---------------------------------------------------------------------------
854 // Big Endian - 48 bits
int48s2BigEndian(char * List,int64s Value)855 void int48s2BigEndian (char* List, int64s Value)
856 {
857 List[0]=(char)(Value>>40);
858 List[1]=(char)(Value>>32);
859 List[2]=(char)(Value>>24);
860 List[3]=(char)(Value>>16);
861 List[4]=(char)(Value>> 8);
862 List[5]=(char) Value;
863 }
864
int48u2BigEndian(char * List,int64u Value)865 void int48u2BigEndian (char* List, int64u Value)
866 {
867 List[0]=(char)(Value>>40);
868 List[1]=(char)(Value>>32);
869 List[2]=(char)(Value>>24);
870 List[3]=(char)(Value>>16);
871 List[4]=(char)(Value>> 8);
872 List[5]=(char) Value;
873 }
874
875 //---------------------------------------------------------------------------
876 // Big Endian - 56 bits
int56s2BigEndian(char * List,int64s Value)877 void int56s2BigEndian (char* List, int64s Value)
878 {
879 List[0]=(char)(Value>>48);
880 List[1]=(char)(Value>>40);
881 List[2]=(char)(Value>>32);
882 List[3]=(char)(Value>>24);
883 List[4]=(char)(Value>>16);
884 List[5]=(char)(Value>> 8);
885 List[6]=(char) Value;
886 }
887
int56u2BigEndian(char * List,int64u Value)888 void int56u2BigEndian (char* List, int64u Value)
889 {
890 List[0]=(char)(Value>>48);
891 List[1]=(char)(Value>>40);
892 List[2]=(char)(Value>>32);
893 List[3]=(char)(Value>>24);
894 List[4]=(char)(Value>>16);
895 List[5]=(char)(Value>> 8);
896 List[6]=(char) Value;
897 }
898
899 //---------------------------------------------------------------------------
900 // Big Endian - 64 bits
int64s2BigEndian(char * List,int64s Value)901 void int64s2BigEndian (char* List, int64s Value)
902 {
903 List[0]=(char)(Value>>56);
904 List[1]=(char)(Value>>48);
905 List[2]=(char)(Value>>40);
906 List[3]=(char)(Value>>32);
907 List[4]=(char)(Value>>24);
908 List[5]=(char)(Value>>16);
909 List[6]=(char)(Value>> 8);
910 List[7]=(char) Value;
911 }
912
int64u2BigEndian(char * List,int64u Value)913 void int64u2BigEndian (char* List, int64u Value)
914 {
915 List[0]=(char)(Value>>56);
916 List[1]=(char)(Value>>48);
917 List[2]=(char)(Value>>40);
918 List[3]=(char)(Value>>32);
919 List[4]=(char)(Value>>24);
920 List[5]=(char)(Value>>16);
921 List[6]=(char)(Value>> 8);
922 List[7]=(char) Value;
923 }
924
925 //---------------------------------------------------------------------------
926 // Big Endian - 128 bits
int128u2BigEndian(char * List,int128u Value)927 void int128u2BigEndian(char* List, int128u Value)
928 {
929 int64u2BigEndian(List, Value.hi);
930 int64u2BigEndian(List+8, Value.lo);
931 }
932
933 //***************************************************************************
934 // Int to Int
935 //***************************************************************************
936
937 //---------------------------------------------------------------------------
938 // int32 - int64
int32s_int64s(int32s High,int32u Low)939 int64s int32s_int64s (int32s High, int32u Low)
940 {
941 return ((((int64s)High)<<32) | Low);
942 }
943
int32u_int64u(int32u High,int32u Low)944 int64u int32u_int64u (int32u High, int32u Low)
945 {
946 return ((((int64s)High)<<32) | Low);
947 }
948
int32s_int64s(int64s & BigInt,int32s High,int32u Low)949 void int32s_int64s (int64s &BigInt, int32s High, int32u Low)
950 {
951 BigInt= ((((int64s)High)<<32) | Low);
952 }
int32u_int64u(int64s & BigInt,int32u High,int32u Low)953 void int32u_int64u (int64s &BigInt, int32u High, int32u Low)
954 {
955 BigInt= ((((int64s)High)<<32) | Low);
956 }
957
int64s_int32s(int64s BigInt,int32s & High,int32u & Low)958 void int64s_int32s (int64s BigInt, int32s &High, int32u &Low)
959 {
960 High = (int32s) ((BigInt & 0xFFFFFFFF00000000LL)>>32);
961 Low = (int32u) ( BigInt & 0x00000000FFFFFFFF);
962 }
963
int64u_int32u(int64u BigInt,int32u & High,int32u & Low)964 void int64u_int32u (int64u BigInt, int32u &High, int32u &Low)
965 {
966 High = (int32u) ((BigInt & 0xFFFFFFFF00000000LL)>>32);
967 Low = (int32u) ( BigInt & 0x00000000FFFFFFFF);
968 }
969
970 //---------------------------------------------------------------------------
971 // Floats and ints
float32_int32s(float32 F,bool Rounded)972 int32s float32_int32s (float32 F, bool Rounded)
973 {
974 //Out of boundaries
975 if (F>=(int32s)0x7FFFFFFF)
976 return (int32s)0x7FFFFFFF;
977 if (F<=(int32s)0x80000000)
978 return (int32s)0x80000000;
979
980 //Not rounded
981 if (!Rounded)
982 return (int32s)F;
983 //Rounded
984 int I1=(int)F;
985 if (F-I1>=0.5f)
986 return I1+1;
987 else
988 return I1;
989 }
990
float32_int64s(float32 F,bool Rounded)991 int64s float32_int64s (float32 F, bool Rounded)
992 {
993 //Out of boundaries
994 if (F>=(int64s)0x7FFFFFFFFFFFFFFFLL)
995 return (int64s)0x7FFFFFFFFFFFFFFFLL;
996 if (F<=(int64s)0x8000000000000000LL)
997 return (int64s)0x8000000000000000LL;
998
999 //Not rounded
1000 if (!Rounded)
1001 return (int64s)F;
1002 //Rounded
1003 int I1=(int)F;
1004 if (F-I1>=0.5f)
1005 return I1+1;
1006 else
1007 return I1;
1008 }
1009
float64_int32s(float64 F,bool Rounded)1010 int32s float64_int32s (float64 F, bool Rounded)
1011 {
1012 //Out of boundaries
1013 if (F>=(int32s)0x7FFFFFFF)
1014 return (int32s)0x7FFFFFFF;
1015 if (F<=(int32s)0x80000000)
1016 return (int32s)0x80000000;
1017
1018 //Not rounded
1019 if (!Rounded)
1020 return (int32s)F;
1021 //Rounded
1022 int32s I1=(int32s)F;
1023 if (F-I1>=0.5)
1024 return I1+1;
1025 else
1026 return I1;
1027 }
1028
float64_int64s(float64 F,bool Rounded)1029 int64s float64_int64s (float64 F, bool Rounded)
1030 {
1031 //Out of boundaries
1032 if (F>=(int64s)0x7FFFFFFFFFFFFFFFLL)
1033 return (int64s)0x7FFFFFFFFFFFFFFFLL;
1034 if (F<=(int64s)0x8000000000000000LL)
1035 return (int64s)0x8000000000000000LL;
1036
1037 //Not rounded
1038 if (!Rounded)
1039 return (int64s)F;
1040 //Rounded
1041 int64s I1=(int64s)F;
1042 if (F-I1>=0.5)
1043 return I1+1;
1044 else
1045 return I1;
1046 }
1047
1048 } //namespace ZenLib
1049