1 #ifndef BMENCODING_H__INCLUDED__ 2 #define BMENCODING_H__INCLUDED__ 31 #pragma warning (push) 32 #pragma warning (disable : 4702) 55 void put_8(
unsigned char c);
66 void memcpy(
const unsigned char* src,
size_t count);
69 void set_pos(
unsigned char* buf_pos);
72 unsigned char* start_;
87 unsigned char get_8() {
return *buf_++; }
90 size_t size()
const {
return size_t(buf_ - start_); }
93 void seek(
int delta) { buf_ += delta; }
96 void memcpy(
unsigned char* dst,
size_t count);
99 const unsigned char*
get_pos()
const {
return buf_; }
115 decoder(
const unsigned char* buf);
120 bool get_32_OR(
bm::word_t* w,
unsigned count);
121 void get_32_AND(
bm::word_t* w,
unsigned count);
152 bool get_32_OR(
bm::word_t* w,
unsigned count);
153 void get_32_AND(
bm::word_t* w,
unsigned count);
164 template<
class TEncoder>
169 : dest_(dest), used_bits_(0), accum_(0)
175 void put_bit(
unsigned value);
178 void put_bits(
unsigned value,
unsigned count);
184 void put_zero_bits(
unsigned count);
187 void gamma(
unsigned value);
193 bic_encode_u16_cm(arr, sz, lo, hi);
209 void bic_encode_u32_cm(
const bm::word_t* arr,
unsigned sz,
213 void flush() {
if (used_bits_) flush_accum(); }
218 dest_.put_32(accum_);
219 used_bits_ = accum_ = 0;
238 template<
class TDecoder>
244 used_bits_(unsigned(sizeof(accum_) * 8)),
252 unsigned get_bits(
unsigned count);
258 bic_decode_u16_cm(arr, sz, lo, hi);
264 bic_decode_u16_cm_bitset(block, sz, lo, hi);
268 bic_decode_u16_cm_dry(sz, lo, hi);
280 void bic_decode_u32_cm(
bm::word_t* arr,
unsigned sz,
285 void bic_decode_u16_rg_bitset(
bm::word_t* block,
unsigned sz,
292 void bic_decode_u16_cm_bitset(
bm::word_t* block,
unsigned sz,
312 template<
typename T,
typename TBitIO>
333 template<
typename T,
typename TBitIO>
372 : buf_(buf), start_(buf)
419 #if (BM_UNALIGNED_ACCESS_OK == 1) 423 *buf_++ = (
unsigned char) s;
425 *buf_++ = (
unsigned char) s;
434 #if (BM_UNALIGNED_ACCESS_OK == 1) 438 unsigned char* buf = buf_;
443 unsigned char a = (
unsigned char) w16;
444 unsigned char b = (
unsigned char) (w16 >> 8);
451 buf_ = (
unsigned char*)buf;
461 BM_ASSERT((buf_ + count) < (start_ + size_));
474 return size_t(buf_ - start_);
501 #if (BM_UNALIGNED_ACCESS_OK == 1) 505 *buf_++ = (
unsigned char) w;
506 *buf_++ = (
unsigned char) (w >> 8);
507 *buf_++ = (
unsigned char) (w >> 16);
508 *buf_++ = (
unsigned char) (w >> 24);
519 #if (BM_UNALIGNED_ACCESS_OK == 1) 523 *buf_++ = (
unsigned char) w;
524 *buf_++ = (
unsigned char) (w >> 8);
525 *buf_++ = (
unsigned char) (w >> 16);
526 *buf_++ = (
unsigned char) (w >> 24);
527 *buf_++ = (
unsigned char) (w >> 32);
528 *buf_++ = (
unsigned char) (w >> 40);
529 *buf_++ = (
unsigned char) (w >> 48);
530 *buf_++ = (
unsigned char) (w >> 56);
541 #if (BM_UNALIGNED_ACCESS_OK == 1) 545 unsigned char* buf = buf_;
550 unsigned char a = (
unsigned char) w32;
551 unsigned char b = (
unsigned char) (w32 >> 8);
552 unsigned char c = (
unsigned char) (w32 >> 16);
553 unsigned char d = (
unsigned char) (w32 >> 24);
561 buf_ = (
unsigned char*)buf;
596 #if (BM_UNALIGNED_ACCESS_OK == 1) 612 #if (BM_UNALIGNED_ACCESS_OK == 1) 617 ((unsigned)
buf_[2] << 16) + ((unsigned)
buf_[3] << 24);
630 #if (BM_UNALIGNED_ACCESS_OK == 1) 661 #if (BM_UNALIGNED_ACCESS_OK == 1) 666 const unsigned char* buf =
buf_;
670 bm::word_t a = buf[0]+ ((unsigned)buf[1] << 8) +
671 ((unsigned)buf[2] << 16) + ((unsigned)buf[3] << 24);
675 buf_ = (
unsigned char*)buf;
693 #if defined(BMAVX2OPT) 694 __m256i* buf_start = (__m256i*)
buf_;
696 __m256i* buf_end = (__m256i*)
buf_;
698 return bm::avx2_or_arr_unal((__m256i*)w, buf_start, buf_end);
699 #elif defined(BMSSE42OPT) || defined(BMSSE2OPT) 700 __m128i* buf_start = (__m128i*)
buf_;
702 __m128i* buf_end = (__m128i*)
buf_;
709 for (
unsigned i = 0; i < count; i+=4)
711 acc &= (w[i+0] |=
get_32());
712 acc &= (w[i+1] |=
get_32());
713 acc &= (w[i+2] |=
get_32());
714 acc &= (w[i+3] |=
get_32());
716 return acc == not_acc;
734 #if defined(BMAVX2OPT) 735 __m256i* buf_start = (__m256i*)
buf_;
737 __m256i* buf_end = (__m256i*)
buf_;
739 bm::avx2_and_arr_unal((__m256i*)w, buf_start, buf_end);
740 #elif defined(BMSSE42OPT) || defined(BMSSE2OPT) 741 __m128i* buf_start = (__m128i*)
buf_;
743 __m128i* buf_end = (__m128i*)
buf_;
747 for (
unsigned i = 0; i < count; i+=4)
772 #if (BM_UNALIGNED_ACCESS_OK == 1) 776 const unsigned char* buf =
buf_;
784 buf_ = (
unsigned char*)buf;
812 ((unsigned)
buf_[2] << 8) + ((unsigned)
buf_[3]);
841 const unsigned char* buf =
buf_;
845 bm::word_t a = ((unsigned)buf[0] << 24)+ ((unsigned)buf[1] << 16) +
846 ((unsigned)buf[2] << 8) + ((unsigned)buf[3]);
850 buf_ = (
unsigned char*)buf;
865 for (
unsigned i = 0; i < count; i+=4)
867 acc &= (w[i+0] |=
get_32());
868 acc &= (w[i+1] |=
get_32());
869 acc &= (w[i+2] |=
get_32());
870 acc &= (w[i+3] |=
get_32());
872 return acc == not_acc;
878 for (
unsigned i = 0; i < count; i+=4)
897 const unsigned char* buf =
buf_;
907 buf_ = (
unsigned char*)buf;
913 template<
typename TEncoder>
917 accum_ |= (value << used_bits_);
918 if (++used_bits_ == (
sizeof(accum_) * 8))
924 template<
typename TEncoder>
927 unsigned used = used_bits_;
928 unsigned acc = accum_;
932 mask >>= (
sizeof(accum_) * 8) - count;
937 unsigned free_bits = unsigned(
sizeof(accum_) * 8) - used;
939 acc |= value << used;
941 if (count <= free_bits)
955 if (used == (
sizeof(accum_) * 8))
966 template<
typename TEncoder>
969 if (++used_bits_ == (
sizeof(accum_) * 8))
975 template<
typename TEncoder>
978 unsigned used = used_bits_;
979 unsigned free_bits = (
sizeof(accum_) * 8) - used;
980 if (count >= free_bits)
986 for ( ;count >=
sizeof(accum_) * 8; count -=
sizeof(accum_) * 8)
996 accum_ |= (1u << used);
997 if (++used == (
sizeof(accum_) * 8))
1005 template<
typename TEncoder>
1014 unsigned used = used_bits_;
1015 unsigned acc = accum_;
1016 const unsigned acc_bits = (
sizeof(acc) * 8);
1017 unsigned free_bits = acc_bits - used;
1020 unsigned count = logv;
1021 if (count >= free_bits)
1027 for ( ;count >= acc_bits; count -= acc_bits)
1038 if (++used == acc_bits)
1048 unsigned mask = (~0u);
1049 mask >>= acc_bits - logv;
1054 acc |= value << used;
1055 free_bits = acc_bits - used;
1056 if (logv <= free_bits)
1063 value >>= free_bits;
1077 template<
typename TEncoder>
1085 unsigned mid_idx = sz >> 1;
1091 unsigned r = hi - lo - sz + 1;
1094 unsigned value = val - lo - mid_idx;
1096 put_bits(value, logv+1);
1100 bic_encode_u16_rg(arr, mid_idx, lo,
gap_word_t(val-1));
1111 template<
typename TEncoder>
1119 unsigned mid_idx = sz >> 1;
1125 unsigned r = hi - lo - sz + 1;
1128 unsigned value = val - lo - mid_idx;
1132 unsigned c = (unsigned)(1ull << (logv + 1)) - n;
1133 int64_t half_c = c >> 1;
1134 int64_t half_r = r >> 1;
1135 int64_t lo1 = half_r - half_c;
1136 int64_t hi1 = half_r + half_c + 1;
1138 logv += (value <= lo1 || value >= hi1);
1140 put_bits(value, logv);
1144 bic_encode_u32_cm(arr, mid_idx, lo, val-1);
1155 template<
typename TEncoder>
1163 unsigned mid_idx = sz >> 1;
1169 unsigned r = hi - lo - sz + 1;
1172 unsigned value = val - lo - mid_idx;
1176 unsigned c = (unsigned)(1ull << (logv + 1)) - n;
1177 int64_t half_c = c >> 1;
1178 int64_t half_r = r >> 1;
1179 int64_t lo1 = half_r - half_c;
1180 int64_t hi1 = half_r + half_c + 1;
1182 logv += (value <= lo1 || value >= hi1);
1184 put_bits(value, logv);
1204 template<
class TDecoder>
1215 unsigned r = hi - lo - sz + 1;
1219 val = get_bits(logv);
1227 unsigned mid_idx = sz >> 1;
1228 val += lo + mid_idx;
1246 template<
class TDecoder>
1259 unsigned r = hi - lo - sz + 1;
1264 unsigned c = unsigned((1ull << (logv + 1)) - r - 1);
1265 int64_t half_c = c >> 1;
1266 int64_t half_r = r >> 1;
1267 int64_t lo1 = half_r - half_c - ((r + 1) & 1);
1268 int64_t hi1 = half_r + half_c + 1;
1269 val = get_bits(logv);
1270 if (val <= lo1 || val >= hi1)
1271 val += (get_bits(1) << logv);
1280 unsigned mid_idx = sz >> 1;
1281 val += lo + mid_idx;
1286 bic_decode_u32_cm(arr, mid_idx, lo, val-1);
1297 template<
class TDecoder>
1310 unsigned r = hi - lo - sz + 1;
1315 unsigned c = unsigned((1ull << (logv + 1)) - r - 1);
1316 int64_t half_c = c >> 1;
1317 int64_t half_r = r >> 1;
1318 int64_t lo1 = half_r - half_c - ((r + 1) & 1);
1319 int64_t hi1 = half_r + half_c + 1;
1320 val = get_bits(logv);
1321 if (val <= lo1 || val >= hi1)
1322 val += (get_bits(1) << logv);
1331 unsigned mid_idx = sz >> 1;
1332 val += lo + mid_idx;
1348 template<
class TDecoder>
1361 unsigned r = hi - lo - sz + 1;
1366 unsigned c = unsigned((1ull << (logv + 1)) - r - 1);
1367 int64_t half_c = c >> 1;
1368 int64_t half_r = r >> 1;
1369 int64_t lo1 = half_r - half_c - ((r + 1) & 1);
1370 int64_t hi1 = half_r + half_c + 1;
1371 val = get_bits(logv);
1372 if (val <= lo1 || val >= hi1)
1373 val += (get_bits(1) << logv);
1382 unsigned mid_idx = sz >> 1;
1383 val += lo + mid_idx;
1394 bic_decode_u16_cm_bitset(block, mid_idx, lo,
bm::gap_word_t(val-1));
1404 template<
class TDecoder>
1417 unsigned r = hi - lo - sz + 1;
1422 unsigned c = unsigned((1ull << (logv + 1)) - r - 1);
1423 int64_t half_c = c >> 1;
1424 int64_t half_r = r >> 1;
1425 int64_t lo1 = half_r - half_c - ((r + 1) & 1);
1426 int64_t hi1 = half_r + half_c + 1;
1427 val = get_bits(logv);
1428 if (val <= lo1 || val >= hi1)
1429 val += (get_bits(1) << logv);
1438 unsigned mid_idx = sz >> 1;
1439 val += lo + mid_idx;
1455 template<
class TDecoder>
1466 unsigned r = hi - lo - sz + 1;
1470 val = get_bits(logv);
1478 unsigned mid_idx = sz >> 1;
1479 val += lo + mid_idx;
1491 bic_decode_u16_rg_bitset(block, mid_idx, lo,
bm::gap_word_t(val - 1));
1501 template<
class TDecoder>
1512 unsigned r = hi - lo - sz + 1;
1516 val = get_bits(logv);
1524 unsigned mid_idx = sz >> 1;
1525 val += lo + mid_idx;
1542 template<
class TDecoder>
1545 unsigned acc = accum_;
1546 unsigned used = used_bits_;
1548 if (used == (
sizeof(acc) * 8))
1550 acc = src_.get_32();
1553 unsigned zero_bits = 0;
1558 zero_bits = unsigned(zero_bits +(
sizeof(acc) * 8) - used);
1560 acc = src_.get_32();
1563 unsigned first_bit_idx =
1564 #if defined(BM_x86) && (defined(__GNUG__) || defined(_MSC_VER)) 1569 acc >>= first_bit_idx;
1570 zero_bits += first_bit_idx;
1571 used += first_bit_idx;
1577 if (used == (
sizeof(acc) * 8))
1579 acc = src_.get_32();
1591 unsigned free_bits = unsigned((
sizeof(acc) * 8) - used);
1592 if (zero_bits <= free_bits)
1602 if (used == (
sizeof(acc) * 8))
1604 acc = src_.get_32();
1612 acc = src_.get_32();
1613 used = zero_bits - free_bits;
1627 template<
class TDecoder>
1631 const unsigned maskFF = ~0u;
1632 unsigned acc = accum_;
1633 unsigned used = used_bits_;
1636 unsigned free_bits = unsigned((
sizeof(acc) * 8) - used);
1637 if (count <= free_bits)
1640 value = acc & (maskFF >> (32 - count));
1646 if (used == (
sizeof(acc) * 8))
1648 acc = src_.get_32();
1653 acc = src_.get_32();
1654 used = count - free_bits;
1655 value |= ((acc & (maskFF >> (32 - used))) << free_bits);
1668 #pragma warning(pop) Structure keeps all-left/right ON bits masks.
void put_64(bm::id64_t w)
Puts 64 bits word into encoding buffer.
void put_8(unsigned char c)
Puts one character into the encoding buffer.
void bic_decode_u16_cm_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode into /dev/null.
const unsigned set_word_shift
void bic_encode_u16_cm(const bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative encoding (array of 16-bit ints) cm - "center-minimal".
void get_32_AND(bm::word_t *w, unsigned count)
unsigned char * position_type
unsigned long long int id64_t
gamma_decoder(TBitIO &bin)
void memcpy(unsigned char *dst, size_t count)
read bytes from the decode buffer
decoder_base(const unsigned char *buf)
Base class for all decoding functionality.
void put_32(bm::word_t w)
Puts 32 bits word into encoding buffer.
bool get_32_OR(bm::word_t *w, unsigned count)
unsigned get_bits(unsigned count)
read number of bits out of the stream
void bic_encode_u16_rg(const bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative encoding (array of 16-bit ints)
void set_pos(unsigned char *buf_pos)
Set current memory stream position.
void seek(int delta)
change current position
Byte based reader for un-aligned bit streaming.
void flush()
Flush the incomplete 32-bit accumulator word.
Class for decoding data from memory buffer.
gamma_encoder(TBitIO &bout)
Class for decoding data from memory buffer.
void stop()
Stop decoding sequence.
void operator()(T value)
Encode word.
decoder decoder_big_endian
Class for decoding data from memory buffer.
bool sse2_or_arr_unal(__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
OR array elements against another array (unaligned) dst |= *src.
bit_in(TDecoder &decoder)
const unsigned char * start_
bm::short_t get_16()
Reads 16-bit word from the decoding buffer.
unsigned sse2_and_arr_unal(__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
AND array elements against another array (unaligned) dst &= *src.
void bic_decode_u16_bitset(bm::word_t *block, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
bool get_32_OR(bm::word_t *w, unsigned count)
Reads block of 32-bit words from the decoding buffer and ORs to the destination.
unsigned short gap_word_t
void put_bits(unsigned value, unsigned count)
issue count bits out of value
Byte based writer for un-aligned bit streaming.
bm::id64_t get_64()
Reads 64-bit word from the decoding buffer.
void bic_decode_u32_cm(bm::word_t *arr, unsigned sz, bm::word_t lo, bm::word_t hi)
Binary Interpolative array decode (32-bit)
void bic_decode_u16_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
void put_zero_bits(unsigned count)
issue specified number of 0s
void put_16(bm::short_t s)
Puts short word (16 bits) into the encoding buffer.
void bic_decode_u16_rg(bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode.
void get_32_AND(bm::word_t *w, unsigned count)
Reads block of 32-bit words from the decoding buffer and ANDs to the destination. ...
decoder(const unsigned char *buf)
Construction.
void put_prefixed_array_16(unsigned char c, const bm::short_t *s, unsigned count, bool encode_count)
Encode 8-bit prefix + an array.
unsigned char get_8()
Reads character from the decoding buffer.
void put_prefixed_array_32(unsigned char c, const bm::word_t *w, unsigned count)
Encode 8-bit prefix + an array.
unsigned char * get_pos() const
Get current memory stream position.
void memcpy(const unsigned char *src, size_t count)
copy bytes into target buffer or just rewind if src is NULL
const unsigned char * buf_
void bic_decode_u16_cm_bitset(bm::word_t *block, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode into bitset (32-bit based)
T operator()(void)
Decode word.
size_t size() const
Returns size of the current encoding stream.
const unsigned set_word_mask
decoder_little_endian(const unsigned char *buf)
void put_bit(unsigned value)
issue single bit into encode bit-stream
encoder(unsigned char *buf, size_t size)
Construction.
Functor for Elias Gamma encoding.
void bic_decode_u16_rg_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode into /dev/null.
void bic_decode_u16_cm(bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode.
void bic_decode_u16(bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode.
unsigned gamma()
decode unsigned value using Elias Gamma coding
void gamma(unsigned value)
Elias Gamma encode the specified value.
void bic_decode_u16_rg_bitset(bm::word_t *block, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode into bitset (32-bit based)
const unsigned char * get_pos() const
Return current buffer pointer.
size_t size() const
Returns size of the current decoding stream.
void put_zero_bit()
issue 0 into output stream
void bic_encode_u16(const bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
Binary Interpolative array decode.
unsigned bit_scan_reverse32(unsigned value)
Bit manipulation primitives (internal)
void bic_encode_u32_cm(const bm::word_t *arr, unsigned sz, bm::word_t lo, bm::word_t hi)
Binary Interpolative encoding (array of 32-bit ints) cm - "center-minimal".
void start()
Start encoding sequence.
bm::word_t get_32()
Reads 32-bit word from the decoding buffer.