// Copyright 2020 Mobilinkd LLC.
#pragma once
#include <algorithm>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <array>
#include <bitset>
#include <tuple>
#include <limits>
namespace modemm17
{
// The make_bitset stuff only works as expected in GCC10 and later.
namespace detail {
/**
* This is the max value for the LLR based on size N.
*/
template <size_t N>
constexpr size_t llr_limit()
{
return (1 << (N - 1)) - 1;
}
/**
* There are (2^(N-1)-1) elements (E) per segment (e.g. N=4, E=7; N=3, E=3).
* These contain the LLR values 1..E. There are 6 segments in the LLR map:
* 1. (-Inf,-2]
* 2. (-2, -1]
* 3. (-1, 0]
* 4. (0, 1]
* 5. (1, 2]
* 6. (2, Inf)
*
* Note the slight asymmetry. This is OK as we are dealing with floats and
* it only matters to an epsilon of the float type.
*/
template <size_t N>
constexpr size_t llr_size()
{
return llr_limit<N>() * 6 + 1;
}
template<size_t LLR>
constexpr std::array<std::tuple<float, std::tuple<int8_t, int8_t>>, llr_size<LLR>()> make_llr_map()
{
constexpr size_t size = llr_size<LLR>();
std::array<std::tuple<float, std::tuple<int8_t, int8_t>>, size> result;
constexpr int8_t limit = llr_limit<LLR>();
constexpr float inc = 1.0 / float(limit);
int8_t i = limit;
int8_t j = limit;
// Output must be ordered by k, ascending.
float k = -3.0 + inc;
for (size_t index = 0; index != size; ++index)
{
auto& a = result[index];
std::get<0>(a) = k;
std::get<0>(std::get<1>(a)) = i;
std::get<1>(std::get<1>(a)) = j;
if (k + 1.0 < 0)
{
j--;
if (j == 0) j = -1;
if (j < -limit) j = -limit;
}
else if (k - 1.0 < 0)
{
i--;
if (i == 0) i = -1;
if (i < -limit) i = -limit;
}
else
{
j++;
if (j == 0) j = 1;
if (j > limit) j = limit;
}
k += inc;
}
return result;
}
}
// template<class...Bools>
// constexpr auto make_bitset(Bools&&...bools)
// {
// return detail::make_bitset(std::make_index_sequence<sizeof...(Bools)>(),
// std::make_tuple(bool(bools)...));
// }
inline int from_4fsk(int symbol)
{
// Convert a 4-FSK symbol to a pair of bits.
switch (symbol)
{
case 1: return 0;
case 3: return 1;
case -1: return 2;
case -3: return 3;
default: abort();
}
}
template <size_t LLR>
auto llr(float sample)
{
static auto symbol_map = detail::make_llr_map<LLR>();
static constexpr float MAX_VALUE = 3.0;
static constexpr float MIN_VALUE = -3.0;
float s = std::min(MAX_VALUE, std::max(MIN_VALUE, sample));
auto it = std::lower_bound(symbol_map.begin(), symbol_map.end(), s,
[](std::tuple<float, std::tuple<int8_t, int8_t>> const& e, float s){
return std::get<0>(e) < s;
});
if (it == symbol_map.end()) return std::get<1>(*symbol_map.rbegin());
return std::get<1>(*it);
}
template <size_t IN1, size_t OUT1, size_t P>
size_t depuncture( // FIXED: MSVC (MULTIPLE DEFINITIONS SAME TEMPLATE)
const std::array<int8_t, IN1>& in,
std::array<int8_t, OUT1>& out,
const std::array<int8_t, P>& p
)
{
size_t index = 0;
size_t pindex = 0;
size_t bit_count = 0;
for (size_t i = 0; i != OUT1 && index < IN1; ++i)
{
if (!p[pindex++])
{
out[i] = 0;
bit_count++;
}
else
{
out[i] = in[index++];
}
if (pindex == P) {
pindex = 0;
}
}
return bit_count;
}
template <size_t IN0, size_t OUT0, size_t P>
size_t puncture( // FIXED::MSVC (MULTIPLE DEFINITIONS OF THE SAME TEMPLATE)
const std::array<uint8_t, IN0>& in,
std::array<int8_t, OUT0>& out,
const std::array<int8_t, P>& p
)
{
size_t index = 0;
size_t pindex = 0;
size_t bit_count = 0;
for (size_t i = 0; i != IN0 && index != OUT0; ++i)
{
if (p[pindex++])
{
out[index++] = in[i];
bit_count++;
}
if (pindex == P) pindex = 0;
}
return bit_count;
}
template <size_t N>
constexpr bool get_bit_index(
const std::array<uint8_t, N>& input,
size_t index
)
{
auto byte_index = index >> 3;
assert(byte_index < N);
auto bit_index = 7 - (index & 7);
return (input[byte_index] & (1 << bit_index)) >> bit_index;
}
template <size_t N>
void set_bit_index(
std::array<uint8_t, N>& input,
size_t index
)
{
auto byte_index = index >> 3;
assert(byte_index < N);
auto bit_index = 7 - (index & 7);
input[byte_index] |= (1 << bit_index);
}
template <size_t N>
void reset_bit_index(
std::array<uint8_t, N>& input,
size_t index
)
{
auto byte_index = index >> 3;
assert(byte_index < N);
auto bit_index = 7 - (index & 7);
input[byte_index] &= ~(1 << bit_index);
}
template <size_t N>
void assign_bit_index(
std::array<uint8_t, N>& input,
size_t index,
bool value
)
{
if (value) set_bit_index(input, index);
else reset_bit_index(input, index);
}
/**
* Sign-extend an n-bit value to a specific signed integer type.
*/
template <typename T, size_t n>
constexpr T to_int(uint8_t v)
{
constexpr auto MAX_LOCAL_INPUT = (1 << (n - 1));
constexpr auto NEGATIVE_OFFSET = std::numeric_limits<typename std::make_unsigned<T>::type>::max() - (MAX_LOCAL_INPUT - 1);
T r = v & (1 << (n - 1)) ? (T)NEGATIVE_OFFSET : 0;
return r + (v & (MAX_LOCAL_INPUT - 1));
}
template <typename T, size_t N>
constexpr auto to_byte_array(std::array<T, N> in)
{
std::array<uint8_t, (N + 7) / 8> out{};
out.fill(0);
size_t i = 0;
size_t b = 0;
for (auto c : in)
{
out[i] |= (c << (7 - b));
if (++b == 8)
{
++i;
b = 0;
}
}
return out;
}
template <typename T, size_t N>
constexpr void to_byte_array(
std::array<T, N> in,
std::array<uint8_t, (N + 7) / 8>& out
)
{
size_t i = 0;
size_t b = 0;
uint8_t tmp = 0;
for (auto c : in)
{
tmp |= (c << (7 - b));
if (++b == 8)
{
out[i] = tmp;
tmp = 0;
++i;
b = 0;
}
}
if (i < out.size()) out[i] = tmp;
}
struct PRBS9
{
static constexpr uint16_t MASK = 0x1FF;
static constexpr uint8_t TAP_1 = 8; // Bit 9
static constexpr uint8_t TAP_2 = 4; // Bit 5
static constexpr uint8_t LOCK_COUNT = 18; // 18 consecutive good bits.
static constexpr uint8_t UNLOCK_COUNT = 25; // bad bits in history required to unlock.
uint16_t state = 1;
bool synced = false;
uint8_t sync_count = 0;
uint32_t bit_count = 0;
uint32_t err_count = 0;
std::array<uint8_t, 16> history;
size_t hist_count = 0;
size_t hist_pos = 0;
void count_errors(bool error)
{
bit_count += 1;
hist_count -= (history[hist_pos >> 3] & (1 << (hist_pos & 7))) != 0;
if (error) {
err_count += 1;
hist_count += 1;
history[hist_pos >> 3] |= (1 << (hist_pos & 7));
if (hist_count >= UNLOCK_COUNT) synced = false;
} else {
history[hist_pos >> 3] &= ~(1 << (hist_pos & 7));
}
if (++hist_pos == 128) hist_pos = 0;
}
// PRBS generator.
bool generate()
{
bool result = ((state >> TAP_1) ^ (state >> TAP_2)) & 1;
state = ((state << 1) | result) & MASK;
return result;
}
// PRBS Syncronizer. Returns 0 if the bit matches the PRBS, otherwise 1.
// When synchronizing the LFSR used in the PRBS, a single bad input bit will
// result in 3 error bits being emitted.
bool synchronize(bool bit)
{
bool result = (bit ^ (state >> TAP_1) ^ (state >> TAP_2)) & 1;
state = ((state << 1) | bit) & MASK;
if (result) {
sync_count = 0; // error
} else {
if (++sync_count == LOCK_COUNT) {
synced = true;
bit_count += LOCK_COUNT;
history.fill(0);
hist_count = 0;
hist_pos = 0;
sync_count = 0;
}
}
return result;
}
// PRBS validator. Returns 0 if the bit matches the PRBS, otherwise 1.
// The results are only valid when sync() returns true;
bool validate(bool bit)
{
bool result;
if (!synced) {
result = synchronize(bit);
} else {
// PRBS is now free-running.
result = bit ^ generate();
count_errors(result);
}
return result;
}
bool sync() const { return synced; }
uint32_t errors() const { assert(synced); return err_count; }
uint32_t bits() const { assert(synced); return bit_count; }
// Reset the state.
void reset()
{
state = 1;
synced = false;
sync_count = 0;
bit_count = 0;
err_count = 0;
history.fill(0);
hist_count = 0;
hist_pos = 0;
}
};
template< class T >
constexpr int popcount( T x ) noexcept
{
int count = 0;
while (x)
{
count += x & 1;
x >>= 1;
}
return count;
}
} // modemm17