oozle 0.1.5

Open source Kraken, Mermaid, Selkie, Leviathan, LZNA, Bitknit decompressor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#pragma once

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <emmintrin.h>

#define assert(x) (void)0

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

inline uint16_t
byteswap_ushort (uint16_t i)
{
  #ifdef __linux__
  uint16_t j;
  j = (i << 8);
  j += (i >> 8);
  return j;
  #else
  return _byteswap_ushort ((unsigned short)i);
  #endif
}

inline uint32_t
byteswap_ulong (uint32_t i)
{
  #ifdef __linux__
  uint32_t j;
  j = (i << 24);
  j += (i << 8) & 0x00FF0000;
  j += (i >> 8) & 0x0000FF00;
  j += (i >> 24);
  return j;
  #else
  return _byteswap_ulong ((unsigned long)i);
  #endif
}

inline uint64_t
byteswap_uint64 (uint64_t i)
{
  #ifdef __linux__
  uint64_t j;
  j = (i << 56);
  j += (i << 40) & 0x00FF000000000000;
  j += (i << 24) & 0x0000FF0000000000;
  j += (i << 8) & 0x000000FF00000000;
  j += (i >> 8) & 0x00000000FF000000;
  j += (i >> 24) & 0x0000000000FF0000;
  j += (i >> 40) & 0x000000000000FF00;
  j += (i >> 56);
  return j;
  #else
  return _byteswap_uint64 ((unsigned long long)i);
  #endif
}

#ifdef __linux__
// GCC __forceinline macro
#define __forceinline inline __attribute__ ((always_inline))
#endif

__forceinline uint8_t
BitScanReverse (uint64_t *const Index, const uint64_t Mask)
{
  #ifdef __linux__
  *Index = 31 - __builtin_clz (Mask);
  return Mask ? 1 : 0;
  #else
  return _BitScanReverse64 ((unsigned long *)Index, Mask);
  #endif
}

__forceinline uint8_t
BitScanForward (uint64_t *const Index, const uint64_t Mask)
{
  #ifdef __linux__
  *Index = __builtin_ctz (Mask);
  return Mask ? 1 : 0;
  #else
  return _BitScanForward64 ((unsigned long *)Index, Mask);
  #endif
}

__forceinline uint32_t
rotl (uint32_t value, int32_t shift)
{
  #ifdef __linux__
  return (((value) << ((int32_t)(shift)))
          | ((value) >> (32 - (int32_t)(shift))));
  #else
  return _rotl ((unsigned int)value, (int)shift);
  #endif
}