mirror of
https://github.com/aicodix/modem.git
synced 2026-04-27 14:30:34 +00:00
experimenting with a scheme for Ribbit
This commit is contained in:
Ahmet Inan
parent
c9ce52c45c
commit
b857741d9d
5 changed files with 136 additions and 459 deletions
4
README.md
vendored
4
README.md
vendored
|
|
@ -3,10 +3,10 @@
|
|||
|
||||
Quick start:
|
||||
|
||||
Create file ```uncoded.dat``` with ```1360``` bits of random data:
|
||||
Create file ```uncoded.dat``` with ```2048``` bits of random data:
|
||||
|
||||
```
|
||||
dd if=/dev/urandom of=uncoded.dat bs=1 count=170
|
||||
dd if=/dev/urandom of=uncoded.dat bs=1 count=256
|
||||
```
|
||||
|
||||
Encode file ```uncoded.dat``` to ```encoded.wav``` [WAV](https://en.wikipedia.org/wiki/WAV) audio file with 8000 Hz sample rate, 16 bits and only 1 (real) channel:
|
||||
|
|
|
|||
275
decode.cc
275
decode.cc
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
OFDM modem decoder
|
||||
|
||||
Copyright 2021 Ahmet Inan <inan@aicodix.de>
|
||||
Copyright 2023 Ahmet Inan <inan@aicodix.de>
|
||||
*/
|
||||
|
||||
#include <algorithm>
|
||||
|
|
@ -10,7 +10,6 @@ Copyright 2021 Ahmet Inan <inan@aicodix.de>
|
|||
#include <cmath>
|
||||
namespace DSP { using std::abs; using std::min; using std::cos; using std::sin; }
|
||||
#include "bip_buffer.hh"
|
||||
#include "theil_sen.hh"
|
||||
#include "xorshift.hh"
|
||||
#include "trigger.hh"
|
||||
#include "complex.hh"
|
||||
|
|
@ -26,7 +25,6 @@ namespace DSP { using std::abs; using std::min; using std::cos; using std::sin;
|
|||
#include "fft.hh"
|
||||
#include "mls.hh"
|
||||
#include "crc.hh"
|
||||
#include "osd.hh"
|
||||
#include "psk.hh"
|
||||
#include "polar_tables.hh"
|
||||
#include "polar_helper.hh"
|
||||
|
|
@ -42,11 +40,12 @@ struct SchmidlCox
|
|||
DSP::FastFourierTransform<symbol_len, cmplx, -1> fwd;
|
||||
DSP::FastFourierTransform<symbol_len, cmplx, 1> bwd;
|
||||
DSP::SMA4<cmplx, value, symbol_len, false> cor;
|
||||
DSP::SMA4<value, value, 2*symbol_len, false> pwr;
|
||||
DSP::SMA4<value, value, symbol_len, false> pwr;
|
||||
DSP::SMA4<value, value, match_len, false> match;
|
||||
DSP::Delay<value, match_del> delay;
|
||||
DSP::SchmittTrigger<value> threshold;
|
||||
DSP::FallingEdgeTrigger falling;
|
||||
DSP::Phasor<cmplx> fsh;
|
||||
cmplx tmp0[symbol_len], tmp1[symbol_len], tmp2[symbol_len];
|
||||
cmplx seq[symbol_len], kern[symbol_len];
|
||||
cmplx cmplx_shift = 0;
|
||||
|
|
@ -72,8 +71,11 @@ public:
|
|||
value cfo_rad = 0;
|
||||
value frac_cfo = 0;
|
||||
|
||||
SchmidlCox(const cmplx *sequence) : threshold(value(0.17*match_len), value(0.19*match_len))
|
||||
SchmidlCox(const cmplx *sequence) : threshold(value(0.2*match_len), value(0.3*match_len))
|
||||
{
|
||||
#if 0
|
||||
fsh.omega(-1, symbol_len);
|
||||
#endif
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
seq[i] = sequence[i];
|
||||
fwd(kern, sequence);
|
||||
|
|
@ -82,8 +84,8 @@ public:
|
|||
}
|
||||
bool operator()(const cmplx *samples)
|
||||
{
|
||||
cmplx P = cor(samples[search_pos+symbol_len] * conj(samples[search_pos+2*symbol_len]));
|
||||
value R = value(0.5) * pwr(norm(samples[search_pos+2*symbol_len]));
|
||||
cmplx P = cor(fsh() * samples[search_pos] * conj(samples[search_pos+symbol_len+guard_len]));
|
||||
value R = value(0.5) * pwr(norm(samples[search_pos]) + norm(samples[search_pos+symbol_len+guard_len]));
|
||||
value min_R = 0.0001 * symbol_len;
|
||||
R = std::max(R, min_R);
|
||||
value timing = match(norm(P) / (R * R));
|
||||
|
|
@ -92,6 +94,8 @@ public:
|
|||
bool collect = threshold(timing);
|
||||
bool process = falling(collect);
|
||||
|
||||
//std::cout << timing << " " << phase << " " << process << std::endl;
|
||||
|
||||
if (!collect && !process)
|
||||
return false;
|
||||
|
||||
|
|
@ -101,6 +105,10 @@ public:
|
|||
index_max = match_del;
|
||||
} else if (index_max < symbol_len + guard_len + match_del) {
|
||||
++index_max;
|
||||
} else if (process) {
|
||||
index_max = 0;
|
||||
timing_max = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!process)
|
||||
|
|
@ -110,11 +118,11 @@ public:
|
|||
|
||||
DSP::Phasor<cmplx> osc;
|
||||
osc.omega(frac_cfo);
|
||||
symbol_pos = search_pos - index_max;
|
||||
symbol_pos = search_pos - index_max + guard_len;
|
||||
index_max = 0;
|
||||
timing_max = 0;
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
tmp1[i] = samples[i+symbol_pos+symbol_len] * osc();
|
||||
tmp1[i] = samples[i+symbol_pos] * osc();
|
||||
fwd(tmp0, tmp1);
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
tmp1[i] = demod_or_erase(tmp0[i], tmp0[bin(i-1)]);
|
||||
|
|
@ -151,15 +159,10 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
void base37_decoder(char *str, long long int val, int len)
|
||||
{
|
||||
for (int i = len-1; i >= 0; --i, val /= 37)
|
||||
str[i] = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[val%37];
|
||||
}
|
||||
|
||||
template <typename value, typename cmplx, int rate>
|
||||
struct Decoder
|
||||
{
|
||||
typedef float value;
|
||||
typedef DSP::Complex<value> cmplx;
|
||||
typedef int8_t code_type;
|
||||
#ifdef __AVX2__
|
||||
typedef SIMD<code_type, 32 / sizeof(code_type)> mesg_type;
|
||||
|
|
@ -167,23 +170,19 @@ struct Decoder
|
|||
typedef SIMD<code_type, 16 / sizeof(code_type)> mesg_type;
|
||||
#endif
|
||||
typedef DSP::Const<value> Const;
|
||||
static const int code_order = 11;
|
||||
static const int sample_rate = 8000;
|
||||
static const int code_order = 12;
|
||||
static const int mod_bits = 2;
|
||||
static const int code_len = 1 << code_order;
|
||||
static const int symbol_len = (1280 * rate) / 8000;
|
||||
static const int filter_len = (((21 * rate) / 8000) & ~3) | 1;
|
||||
static const int symbol_len = 256;
|
||||
static const int filter_len = 33;
|
||||
static const int guard_len = symbol_len / 8;
|
||||
static const int max_bits = 1360 + 32;
|
||||
static const int cons_cols = 256;
|
||||
static const int cons_rows = 4;
|
||||
static const int cons_total = cons_rows * cons_cols;
|
||||
static const int code_off = - cons_cols / 2;
|
||||
static const int mls0_len = 127;
|
||||
static const int mls0_off = - mls0_len + 1;
|
||||
static const int mls0_poly = 0b10001001;
|
||||
static const int mls1_len = 255;
|
||||
static const int mls1_off = - mls1_len / 2;
|
||||
static const int mls1_poly = 0b100101011;
|
||||
static const int data_bits = 2048;
|
||||
static const int mesg_bits = data_bits + 32;
|
||||
static const int subcarrier_count = 64;
|
||||
static const int payload_symbols = 32;
|
||||
static const int first_subcarrier = 16;
|
||||
static const int cons_total = payload_symbols * subcarrier_count;
|
||||
static const int buffer_len = 6 * (symbol_len + guard_len);
|
||||
static const int search_pos = buffer_len - 4 * (symbol_len + guard_len);
|
||||
DSP::ReadPCM<value> *pcm;
|
||||
|
|
@ -191,29 +190,18 @@ struct Decoder
|
|||
DSP::BlockDC<value, value> blockdc;
|
||||
DSP::Hilbert<cmplx, filter_len> hilbert;
|
||||
DSP::BipBuffer<cmplx, buffer_len> input_hist;
|
||||
DSP::TheilSenEstimator<value, cons_cols> tse;
|
||||
SchmidlCox<value, cmplx, search_pos, symbol_len/2, guard_len> correlator;
|
||||
CODE::CRC<uint16_t> crc0;
|
||||
CODE::CRC<uint32_t> crc1;
|
||||
CODE::OrderedStatisticsDecoder<255, 71, 4> osddec;
|
||||
SchmidlCox<value, cmplx, search_pos, symbol_len, guard_len> correlator;
|
||||
CODE::CRC<uint32_t> crc;
|
||||
CODE::PolarEncoder<mesg_type> polarenc;
|
||||
CODE::PolarListDecoder<mesg_type, code_order> polardec;
|
||||
int8_t genmat[255*71];
|
||||
mesg_type mesg[max_bits], mess[code_len];
|
||||
mesg_type mesg[mesg_bits], mess[code_len];
|
||||
code_type code[code_len];
|
||||
cmplx cons[cons_total], prev[cons_cols];
|
||||
cmplx cons[cons_total], prev[subcarrier_count];
|
||||
cmplx fdom[symbol_len], tdom[symbol_len];
|
||||
value index[cons_cols], phase[cons_cols];
|
||||
value cfo_rad, sfo_rad;
|
||||
const uint32_t *frozen_bits;
|
||||
int symbol_pos;
|
||||
int oper_mode;
|
||||
int crc_bits;
|
||||
|
||||
static int bin(int carrier)
|
||||
{
|
||||
return (carrier + symbol_len) % symbol_len;
|
||||
}
|
||||
static int nrz(bool bit)
|
||||
{
|
||||
return 1 - 2 * bit;
|
||||
|
|
@ -227,20 +215,20 @@ struct Decoder
|
|||
return 0;
|
||||
return cons;
|
||||
}
|
||||
const cmplx *mls0_seq()
|
||||
const cmplx *sync_seq()
|
||||
{
|
||||
CODE::MLS seq0(mls0_poly);
|
||||
for (int i = 0; i < symbol_len/2; ++i)
|
||||
CODE::MLS seq(0b1100111);
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
fdom[i] = 0;
|
||||
for (int i = 0; i < mls0_len; ++i)
|
||||
fdom[(i+mls0_off/2+symbol_len/2)%(symbol_len/2)] = nrz(seq0());
|
||||
for (int i = first_subcarrier + 1; i < first_subcarrier + subcarrier_count; ++i)
|
||||
fdom[i] = nrz(seq());
|
||||
return fdom;
|
||||
}
|
||||
void systematic()
|
||||
{
|
||||
polarenc(mess, mesg, frozen_bits, code_order);
|
||||
int code_bits = 1 << code_order;
|
||||
for (int i = 0, j = 0; i < code_bits && j < crc_bits; ++i)
|
||||
for (int i = 0, j = 0; i < code_bits && j < mesg_bits; ++i)
|
||||
if (!((frozen_bits[i/32] >> (i%32)) & 1))
|
||||
mesg[j++] = mess[i];
|
||||
}
|
||||
|
|
@ -258,25 +246,15 @@ struct Decoder
|
|||
}
|
||||
const cmplx *next_sample()
|
||||
{
|
||||
cmplx tmp;
|
||||
pcm->read(reinterpret_cast<value *>(&tmp), 1);
|
||||
if (pcm->channels() == 1)
|
||||
tmp = hilbert(blockdc(tmp.real()));
|
||||
return input_hist(tmp);
|
||||
value real;
|
||||
pcm->read(&real, 1);
|
||||
return input_hist(hilbert(blockdc(real)));
|
||||
}
|
||||
Decoder(uint8_t *out, int *len, DSP::ReadPCM<value> *pcm, int skip_count) :
|
||||
pcm(pcm), correlator(mls0_seq()), crc0(0xA8F4), crc1(0x8F6E37A0)
|
||||
pcm(pcm), correlator(sync_seq()), crc(0x8F6E37A0)
|
||||
{
|
||||
CODE::BoseChaudhuriHocquenghemGenerator<255, 71>::matrix(genmat, true, {
|
||||
0b100011101, 0b101110111, 0b111110011, 0b101101001,
|
||||
0b110111101, 0b111100111, 0b100101011, 0b111010111,
|
||||
0b000010011, 0b101100101, 0b110001011, 0b101100011,
|
||||
0b100011011, 0b100111111, 0b110001101, 0b100101101,
|
||||
0b101011111, 0b111111001, 0b111000011, 0b100111001,
|
||||
0b110101001, 0b000011111, 0b110000111, 0b110110001});
|
||||
|
||||
blockdc.samples(2*(symbol_len+guard_len));
|
||||
DSP::Phasor<cmplx> osc;
|
||||
frozen_bits = frozen_4096_2080;
|
||||
blockdc.samples(filter_len);
|
||||
const cmplx *buf;
|
||||
bool okay;
|
||||
do {
|
||||
|
|
@ -290,70 +268,26 @@ struct Decoder
|
|||
symbol_pos = correlator.symbol_pos;
|
||||
cfo_rad = correlator.cfo_rad;
|
||||
std::cerr << "symbol pos: " << symbol_pos << std::endl;
|
||||
std::cerr << "coarse cfo: " << cfo_rad * (rate / Const::TwoPi()) << " Hz " << std::endl;
|
||||
|
||||
osc.omega(-cfo_rad);
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
tdom[i] = buf[i+symbol_pos+(symbol_len+guard_len)] * osc();
|
||||
fwd(fdom, tdom);
|
||||
CODE::MLS seq1(mls1_poly);
|
||||
for (int i = 0; i < mls1_len; ++i)
|
||||
fdom[bin(i+mls1_off)] *= nrz(seq1());
|
||||
int8_t soft[mls1_len];
|
||||
uint8_t data[(mls1_len+7)/8];
|
||||
for (int i = 0; i < mls1_len; ++i)
|
||||
soft[i] = std::min<value>(std::max<value>(
|
||||
std::nearbyint(127 * demod_or_erase(
|
||||
fdom[bin(i+mls1_off)], fdom[bin(i-1+mls1_off)]).real()),
|
||||
-128), 127);
|
||||
bool unique = osddec(data, soft, genmat);
|
||||
if (!unique) {
|
||||
std::cerr << "OSD error." << std::endl;
|
||||
continue;
|
||||
}
|
||||
uint64_t md = 0;
|
||||
for (int i = 0; i < 55; ++i)
|
||||
md |= (uint64_t)CODE::get_be_bit(data, i) << i;
|
||||
uint16_t cs = 0;
|
||||
for (int i = 0; i < 16; ++i)
|
||||
cs |= (uint16_t)CODE::get_be_bit(data, i+55) << i;
|
||||
crc0.reset();
|
||||
if (crc0(md<<9) != cs) {
|
||||
std::cerr << "header CRC error." << std::endl;
|
||||
continue;
|
||||
}
|
||||
oper_mode = md & 255;
|
||||
if (oper_mode && (oper_mode < 14 || oper_mode > 16)) {
|
||||
std::cerr << "operation mode " << oper_mode << " unsupported." << std::endl;
|
||||
continue;
|
||||
}
|
||||
std::cerr << "oper mode: " << oper_mode << std::endl;
|
||||
if ((md>>8) == 0 || (md>>8) >= 129961739795077L) {
|
||||
std::cerr << "call sign unsupported." << std::endl;
|
||||
continue;
|
||||
}
|
||||
char call_sign[10];
|
||||
base37_decoder(call_sign, md>>8, 9);
|
||||
call_sign[9] = 0;
|
||||
std::cerr << "call sign: " << call_sign << std::endl;
|
||||
std::cerr << "coarse cfo: " << cfo_rad * (sample_rate / Const::TwoPi()) << " Hz " << std::endl;
|
||||
okay = true;
|
||||
} while (skip_count--);
|
||||
|
||||
*len = 0;
|
||||
if (!okay || !oper_mode)
|
||||
if (!okay)
|
||||
return;
|
||||
|
||||
for (int i = 0; i < symbol_pos+(symbol_len+guard_len); ++i)
|
||||
DSP::Phasor<cmplx> osc;
|
||||
osc.omega(-cfo_rad);
|
||||
for (int i = 0; i < symbol_pos; ++i)
|
||||
buf = next_sample();
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
tdom[i] = buf[i] * osc();
|
||||
for (int i = 0; i < guard_len; ++i)
|
||||
osc();
|
||||
fwd(fdom, tdom);
|
||||
for (int i = 0; i < cons_cols; ++i)
|
||||
prev[i] = fdom[bin(i+code_off)];
|
||||
for (int i = 0; i < subcarrier_count; ++i)
|
||||
prev[i] = fdom[first_subcarrier+i];
|
||||
std::cerr << "demod ";
|
||||
for (int j = 0; j < cons_rows; ++j) {
|
||||
for (int j = 0; j < payload_symbols; ++j) {
|
||||
for (int i = 0; i < symbol_len+guard_len; ++i)
|
||||
buf = next_sample();
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
|
|
@ -361,56 +295,30 @@ struct Decoder
|
|||
for (int i = 0; i < guard_len; ++i)
|
||||
osc();
|
||||
fwd(fdom, tdom);
|
||||
for (int i = 0; i < cons_cols; ++i)
|
||||
cons[cons_cols*j+i] = demod_or_erase(fdom[bin(i+code_off)], prev[i]);
|
||||
for (int i = 0; i < cons_cols; ++i)
|
||||
prev[i] = fdom[bin(i+code_off)];
|
||||
for (int i = 0; i < subcarrier_count; ++i)
|
||||
cons[subcarrier_count*j+i] = demod_or_erase(fdom[first_subcarrier+i], prev[i]);
|
||||
for (int i = 0; i < subcarrier_count; ++i)
|
||||
prev[i] = fdom[first_subcarrier+i];
|
||||
std::cerr << ".";
|
||||
}
|
||||
std::cerr << " done" << std::endl;
|
||||
if (1) {
|
||||
value sum_slope = 0, sum_yint = 0;
|
||||
for (int j = 0; j < cons_rows; ++j) {
|
||||
for (int i = 0; i < cons_cols; ++i) {
|
||||
code_type tmp[mod_bits];
|
||||
mod_hard(tmp, cons[cons_cols*j+i]);
|
||||
index[i] = i + code_off;
|
||||
phase[i] = arg(cons[cons_cols*j+i] * conj(mod_map(tmp)));
|
||||
}
|
||||
tse.compute(index, phase, cons_cols);
|
||||
//std::cerr << "Theil-Sen slope = " << tse.slope() << std::endl;
|
||||
//std::cerr << "Theil-Sen yint = " << tse.yint() << std::endl;
|
||||
sum_slope += tse.slope();
|
||||
sum_yint += tse.yint();
|
||||
for (int i = 0; i < cons_cols; ++i)
|
||||
cons[cons_cols*j+i] *= DSP::polar<value>(1, -tse(i+code_off));
|
||||
}
|
||||
value avg_slope = sum_slope / cons_rows;
|
||||
value avg_yint = sum_yint / cons_rows;
|
||||
//for (int i = 0; i < cons_cnt; ++i)
|
||||
// cons[i] *= DSP::polar<value>(1, -(avg_yint+avg_slope*((i%cons_cols)+code_off)));
|
||||
sfo_rad -= avg_slope * symbol_len / value(symbol_len+guard_len);
|
||||
cfo_rad += avg_yint / (symbol_len+guard_len);
|
||||
std::cerr << "coarse sfo: " << 1000000 * sfo_rad / Const::TwoPi() << " ppm" << std::endl;
|
||||
std::cerr << "finer cfo: " << cfo_rad * (rate / Const::TwoPi()) << " Hz " << std::endl;
|
||||
}
|
||||
if (1) {
|
||||
std::cerr << "Es/N0 (dB):";
|
||||
value sp = 0, np = 0;
|
||||
for (int j = 0; j < cons_rows; ++j) {
|
||||
for (int i = 0; i < cons_cols; ++i) {
|
||||
for (int j = 0; j < payload_symbols; ++j) {
|
||||
for (int i = 0; i < subcarrier_count; ++i) {
|
||||
code_type tmp[mod_bits];
|
||||
mod_hard(tmp, cons[cons_cols*j+i]);
|
||||
mod_hard(tmp, cons[subcarrier_count*j+i]);
|
||||
cmplx hard = mod_map(tmp);
|
||||
cmplx error = cons[cons_cols*j+i] - hard;
|
||||
cmplx error = cons[subcarrier_count*j+i] - hard;
|
||||
sp += norm(hard);
|
||||
np += norm(error);
|
||||
}
|
||||
value precision = sp / np;
|
||||
value snr = DSP::decibel(precision);
|
||||
std::cerr << " " << snr;
|
||||
for (int i = 0; i < cons_cols; ++i)
|
||||
mod_soft(code+2*(cons_cols*j+i), cons[cons_cols*j+i], precision);
|
||||
for (int i = 0; i < subcarrier_count; ++i)
|
||||
mod_soft(code+mod_bits*(subcarrier_count*j+i), cons[subcarrier_count*j+i], precision);
|
||||
}
|
||||
std::cerr << std::endl;
|
||||
} else {
|
||||
|
|
@ -418,25 +326,6 @@ struct Decoder
|
|||
for (int i = 0; i < cons_total; ++i)
|
||||
mod_soft(code+mod_bits*i, cons[i], precision);
|
||||
}
|
||||
int data_bits = 0;
|
||||
switch (oper_mode) {
|
||||
case 14:
|
||||
data_bits = 1360;
|
||||
frozen_bits = frozen_2048_1392;
|
||||
break;
|
||||
case 15:
|
||||
data_bits = 1024;
|
||||
frozen_bits = frozen_2048_1056;
|
||||
break;
|
||||
case 16:
|
||||
data_bits = 680;
|
||||
frozen_bits = frozen_2048_712;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
*len = data_bits / 8;
|
||||
crc_bits = data_bits + 32;
|
||||
CODE::PolarHelper<mesg_type>::PATH metric[mesg_type::SIZE];
|
||||
polardec(metric, mesg, code, frozen_bits, code_order);
|
||||
systematic();
|
||||
|
|
@ -446,19 +335,19 @@ struct Decoder
|
|||
std::sort(order, order+mesg_type::SIZE, [metric](int a, int b){ return metric[a] < metric[b]; });
|
||||
int best = -1;
|
||||
for (int k = 0; k < mesg_type::SIZE; ++k) {
|
||||
crc1.reset();
|
||||
for (int i = 0; i < crc_bits; ++i)
|
||||
crc1(mesg[i].v[order[k]] < 0);
|
||||
if (crc1() == 0) {
|
||||
crc.reset();
|
||||
for (int i = 0; i < mesg_bits; ++i)
|
||||
crc(mesg[i].v[order[k]] < 0);
|
||||
if (crc() == 0) {
|
||||
best = order[k];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (best < 0) {
|
||||
std::cerr << "payload decoding error." << std::endl;
|
||||
*len = 0;
|
||||
return;
|
||||
}
|
||||
*len = data_bits / 8;
|
||||
int flips = 0;
|
||||
for (int i = 0, j = 0; i < data_bits; ++i, ++j) {
|
||||
while ((frozen_bits[j / 32] >> (j % 32)) & 1)
|
||||
|
|
@ -479,9 +368,6 @@ int main(int argc, char **argv)
|
|||
return 1;
|
||||
}
|
||||
|
||||
typedef float value;
|
||||
typedef DSP::Complex<value> cmplx;
|
||||
|
||||
const char *output_name = argv[1];
|
||||
if (output_name[0] == '-' && output_name[1] == 0)
|
||||
output_name = "/dev/stdout";
|
||||
|
|
@ -489,10 +375,10 @@ int main(int argc, char **argv)
|
|||
if (input_name[0] == '-' && input_name[1] == 0)
|
||||
input_name = "/dev/stdin";
|
||||
|
||||
DSP::ReadWAV<value> input_file(input_name);
|
||||
DSP::ReadWAV<float> input_file(input_name);
|
||||
|
||||
if (input_file.channels() < 1 || input_file.channels() > 2) {
|
||||
std::cerr << "Only real or analytic signal (one or two channels) supported." << std::endl;
|
||||
if (input_file.channels() != 1) {
|
||||
std::cerr << "Only real signal (one channel) supported." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -500,28 +386,17 @@ int main(int argc, char **argv)
|
|||
if (argc > 3)
|
||||
skip_count = std::atoi(argv[3]);
|
||||
|
||||
const int data_max = 1360 / 8;
|
||||
const int data_max = 2048 / 8;
|
||||
uint8_t *output_data = new uint8_t[data_max];
|
||||
int data_len = 0;
|
||||
|
||||
switch (input_file.rate()) {
|
||||
case 8000:
|
||||
delete new Decoder<value, cmplx, 8000>(output_data, &data_len, &input_file, skip_count);
|
||||
break;
|
||||
case 16000:
|
||||
delete new Decoder<value, cmplx, 16000>(output_data, &data_len, &input_file, skip_count);
|
||||
break;
|
||||
case 44100:
|
||||
delete new Decoder<value, cmplx, 44100>(output_data, &data_len, &input_file, skip_count);
|
||||
break;
|
||||
case 48000:
|
||||
delete new Decoder<value, cmplx, 48000>(output_data, &data_len, &input_file, skip_count);
|
||||
break;
|
||||
default:
|
||||
if (input_file.rate() != 8000) {
|
||||
std::cerr << "Unsupported sample rate." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
delete new Decoder(output_data, &data_len, &input_file, skip_count);
|
||||
|
||||
std::ofstream output_file(output_name, std::ios::binary | std::ios::trunc);
|
||||
if (output_file.bad()) {
|
||||
std::cerr << "Couldn't open file \"" << output_name << "\" for writing." << std::endl;
|
||||
|
|
|
|||
308
encode.cc
308
encode.cc
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
OFDM modem encoder
|
||||
|
||||
Copyright 2021 Ahmet Inan <inan@aicodix.de>
|
||||
Copyright 2023 Ahmet Inan <inan@aicodix.de>
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
|
|
@ -9,9 +9,9 @@ Copyright 2021 Ahmet Inan <inan@aicodix.de>
|
|||
#include <cmath>
|
||||
#include "xorshift.hh"
|
||||
#include "complex.hh"
|
||||
#include "utils.hh"
|
||||
#include "phasor.hh"
|
||||
#include "bitman.hh"
|
||||
#include "decibel.hh"
|
||||
#include "utils.hh"
|
||||
#include "fft.hh"
|
||||
#include "wav.hh"
|
||||
#include "pcm.hh"
|
||||
|
|
@ -21,325 +21,131 @@ Copyright 2021 Ahmet Inan <inan@aicodix.de>
|
|||
#include "polar_tables.hh"
|
||||
#include "polar_helper.hh"
|
||||
#include "polar_encoder.hh"
|
||||
#include "bose_chaudhuri_hocquenghem_encoder.hh"
|
||||
|
||||
template <typename value, typename cmplx, int rate>
|
||||
struct Encoder
|
||||
{
|
||||
typedef float value;
|
||||
typedef DSP::Complex<value> cmplx;
|
||||
typedef int8_t code_type;
|
||||
static const int mod_bits = 2;
|
||||
static const int code_order = 11;
|
||||
static const int code_order = 12;
|
||||
static const int code_len = 1 << code_order;
|
||||
static const int symbol_len = (1280 * rate) / 8000;
|
||||
static const int symbol_len = 256;
|
||||
static const int guard_len = symbol_len / 8;
|
||||
static const int max_bits = 1360 + 32;
|
||||
static const int cons_cols = 256;
|
||||
static const int cons_rows = 4;
|
||||
static const int mls0_len = 127;
|
||||
static const int mls0_poly = 0b10001001;
|
||||
static const int mls1_len = 255;
|
||||
static const int mls1_poly = 0b100101011;
|
||||
static const int mls2_poly = 0b100101010001;
|
||||
static const int data_bits = 2048;
|
||||
static const int mesg_bits = data_bits + 32;
|
||||
static const int subcarrier_count = 64;
|
||||
static const int payload_symbols = 32;
|
||||
static const int first_subcarrier = 16;
|
||||
DSP::WritePCM<value> *pcm;
|
||||
DSP::FastFourierTransform<symbol_len, cmplx, 1> bwd;
|
||||
DSP::FastFourierTransform<4*symbol_len, cmplx, -1> fwd4;
|
||||
DSP::FastFourierTransform<4*symbol_len, cmplx, 1> bwd4;
|
||||
CODE::CRC<uint16_t> crc0;
|
||||
CODE::CRC<uint32_t> crc1;
|
||||
CODE::BoseChaudhuriHocquenghemEncoder<255, 71> bchenc;
|
||||
CODE::CRC<uint32_t> crc;
|
||||
CODE::PolarSysEnc<code_type> polarenc;
|
||||
code_type code[code_len], mesg[max_bits];
|
||||
cmplx fdom[symbol_len], fdom4[4*symbol_len];
|
||||
cmplx tdom[symbol_len], tdom4[4*symbol_len];
|
||||
cmplx temp[symbol_len];
|
||||
cmplx guard[guard_len];
|
||||
cmplx papr_min, papr_max;
|
||||
int code_off;
|
||||
int mls0_off;
|
||||
int mls1_off;
|
||||
code_type code[code_len], mesg[mesg_bits];
|
||||
cmplx fdom[symbol_len], tdom[symbol_len], guard[guard_len];
|
||||
|
||||
static int bin(int carrier)
|
||||
{
|
||||
return (carrier + symbol_len) % symbol_len;
|
||||
}
|
||||
static int bin4(int carrier)
|
||||
{
|
||||
return (carrier + 4*symbol_len) % (4*symbol_len);
|
||||
}
|
||||
static int nrz(bool bit)
|
||||
{
|
||||
return 1 - 2 * bit;
|
||||
}
|
||||
void improve_papr()
|
||||
void symbol()
|
||||
{
|
||||
for (int i = 0; i < 4*symbol_len; ++i)
|
||||
fdom4[i] = 0;
|
||||
for (int i = -symbol_len/2; i < symbol_len/2; ++i)
|
||||
fdom4[bin4(i)] = fdom[bin(i)];
|
||||
bwd4(tdom4, fdom4);
|
||||
for (int i = 0; i < 4*symbol_len; ++i)
|
||||
tdom4[i] /= std::sqrt(value(4*symbol_len));
|
||||
for (int i = 0; i < 4*symbol_len; ++i) {
|
||||
value amp = std::max(std::abs(tdom4[i].real()), std::abs(tdom4[i].imag()));
|
||||
if (amp > value(1))
|
||||
tdom4[i] /= amp;
|
||||
}
|
||||
fwd4(fdom4, tdom4);
|
||||
for (int i = -symbol_len/2; i < symbol_len/2; ++i)
|
||||
if (norm(temp[bin(i)]))
|
||||
temp[bin(i)] = fdom4[bin4(i)] / std::sqrt(value(4*symbol_len));
|
||||
else
|
||||
temp[bin(i)] = 0;
|
||||
}
|
||||
void symbol(bool papr_reduction = true)
|
||||
{
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
temp[i] = fdom[i];
|
||||
if (papr_reduction)
|
||||
improve_papr();
|
||||
bwd(tdom, temp);
|
||||
bwd(tdom, fdom);
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
tdom[i] /= std::sqrt(value(8*symbol_len));
|
||||
for (int i = 0; i < guard_len; ++i) {
|
||||
value x = value(i) / value(guard_len - 1);
|
||||
value ratio(0.5);
|
||||
x = std::min(x, ratio) / ratio;
|
||||
x = value(0.5) * (value(1) - std::cos(DSP::Const<value>::Pi() * x));
|
||||
guard[i] = DSP::lerp(guard[i], tdom[i+symbol_len-guard_len], x);
|
||||
}
|
||||
cmplx peak, mean;
|
||||
for (int i = 0; i < symbol_len; ++i) {
|
||||
cmplx power(tdom[i].real() * tdom[i].real(), tdom[i].imag() * tdom[i].imag());
|
||||
peak = cmplx(std::max(peak.real(), power.real()), std::max(peak.imag(), power.imag()));
|
||||
mean += power;
|
||||
}
|
||||
if (mean.real() > 0 && mean.imag() > 0) {
|
||||
cmplx papr(peak.real() / mean.real(), peak.imag() / mean.imag());
|
||||
papr *= value(symbol_len);
|
||||
papr_min = cmplx(std::min(papr_min.real(), papr.real()), std::min(papr_min.imag(), papr.imag()));
|
||||
papr_max = cmplx(std::max(papr_max.real(), papr.real()), std::max(papr_max.imag(), papr.imag()));
|
||||
}
|
||||
pcm->write(reinterpret_cast<value *>(guard), guard_len, 2);
|
||||
pcm->write(reinterpret_cast<value *>(tdom), symbol_len, 2);
|
||||
for (int i = 0; i < guard_len; ++i)
|
||||
guard[i] = tdom[i];
|
||||
}
|
||||
void pilot_block()
|
||||
{
|
||||
CODE::MLS seq2(mls2_poly);
|
||||
value code_fac = std::sqrt(value(symbol_len) / value(cons_cols));
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
fdom[i] = 0;
|
||||
for (int i = code_off; i < code_off + cons_cols; ++i)
|
||||
fdom[bin(i)] = code_fac * nrz(seq2());
|
||||
symbol();
|
||||
}
|
||||
void schmidl_cox()
|
||||
{
|
||||
CODE::MLS seq0(mls0_poly);
|
||||
value mls0_fac = std::sqrt(value(2 * symbol_len) / value(mls0_len));
|
||||
CODE::MLS seq(0b1100111);
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
fdom[i] = 0;
|
||||
fdom[bin(mls0_off-2)] = mls0_fac;
|
||||
for (int i = 0; i < mls0_len; ++i)
|
||||
fdom[bin(2*i+mls0_off)] = nrz(seq0());
|
||||
for (int i = 0; i < mls0_len; ++i)
|
||||
fdom[bin(2*i+mls0_off)] *= fdom[bin(2*(i-1)+mls0_off)];
|
||||
symbol(false);
|
||||
}
|
||||
void meta_data(uint64_t md)
|
||||
{
|
||||
uint8_t data[9] = { 0 }, parity[23] = { 0 };
|
||||
for (int i = 0; i < 55; ++i)
|
||||
CODE::set_be_bit(data, i, (md>>i)&1);
|
||||
crc0.reset();
|
||||
uint16_t cs = crc0(md << 9);
|
||||
for (int i = 0; i < 16; ++i)
|
||||
CODE::set_be_bit(data, i+55, (cs>>i)&1);
|
||||
bchenc(data, parity);
|
||||
CODE::MLS seq4(mls1_poly);
|
||||
value mls1_fac = std::sqrt(value(symbol_len) / value(mls1_len));
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
fdom[i] = 0;
|
||||
fdom[bin(mls1_off-1)] = mls1_fac;
|
||||
for (int i = 0; i < 71; ++i)
|
||||
fdom[bin(i+mls1_off)] = nrz(CODE::get_be_bit(data, i));
|
||||
for (int i = 71; i < mls1_len; ++i)
|
||||
fdom[bin(i+mls1_off)] = nrz(CODE::get_be_bit(parity, i-71));
|
||||
for (int i = 0; i < mls1_len; ++i)
|
||||
fdom[bin(i+mls1_off)] *= fdom[bin(i-1+mls1_off)];
|
||||
for (int i = 0; i < mls1_len; ++i)
|
||||
fdom[bin(i+mls1_off)] *= nrz(seq4());
|
||||
#if 0
|
||||
fdom[first_subcarrier+1] = std::sqrt(value(2 * symbol_len) / value(subcarrier_count));
|
||||
for (int i = first_subcarrier + 2; i < first_subcarrier + subcarrier_count + 1; ++i)
|
||||
fdom[i] = fdom[i-1] * cmplx(nrz(seq()));
|
||||
symbol();
|
||||
for (int i = first_subcarrier; i < first_subcarrier + subcarrier_count; ++i)
|
||||
fdom[i] = fdom[i+1];
|
||||
fdom[first_subcarrier+subcarrier_count] = 0;
|
||||
symbol();
|
||||
#else
|
||||
fdom[first_subcarrier] = std::sqrt(value(2 * symbol_len) / value(subcarrier_count));
|
||||
for (int i = first_subcarrier + 1; i < first_subcarrier + subcarrier_count; ++i)
|
||||
fdom[i] = fdom[i-1] * cmplx(nrz(seq()));
|
||||
symbol();
|
||||
symbol();
|
||||
#endif
|
||||
}
|
||||
cmplx mod_map(code_type *b)
|
||||
{
|
||||
return PhaseShiftKeying<4, cmplx, code_type>::map(b);
|
||||
}
|
||||
Encoder(DSP::WritePCM<value> *pcm, const uint8_t *inp, int freq_off, uint64_t call_sign, int oper_mode) :
|
||||
pcm(pcm), crc0(0xA8F4), crc1(0x8F6E37A0), bchenc({
|
||||
0b100011101, 0b101110111, 0b111110011, 0b101101001,
|
||||
0b110111101, 0b111100111, 0b100101011, 0b111010111,
|
||||
0b000010011, 0b101100101, 0b110001011, 0b101100011,
|
||||
0b100011011, 0b100111111, 0b110001101, 0b100101101,
|
||||
0b101011111, 0b111111001, 0b111000011, 0b100111001,
|
||||
0b110101001, 0b000011111, 0b110000111, 0b110110001})
|
||||
Encoder(DSP::WritePCM<value> *pcm, const uint8_t *inp) : pcm(pcm), crc(0x8F6E37A0)
|
||||
{
|
||||
int offset = (freq_off * symbol_len) / rate;
|
||||
code_off = offset - cons_cols / 2;
|
||||
mls0_off = offset - mls0_len + 1;
|
||||
mls1_off = offset - mls1_len / 2;
|
||||
papr_min = cmplx(1000, 1000), papr_max = cmplx(-1000, -1000);
|
||||
pilot_block();
|
||||
schmidl_cox();
|
||||
meta_data((call_sign << 8) | oper_mode);
|
||||
if (oper_mode > 0) {
|
||||
const uint32_t *frozen_bits = nullptr;
|
||||
int data_bits = 0;
|
||||
switch (oper_mode) {
|
||||
case 14:
|
||||
data_bits = 1360;
|
||||
frozen_bits = frozen_2048_1392;
|
||||
break;
|
||||
case 15:
|
||||
data_bits = 1024;
|
||||
frozen_bits = frozen_2048_1056;
|
||||
break;
|
||||
case 16:
|
||||
data_bits = 680;
|
||||
frozen_bits = frozen_2048_712;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < data_bits; ++i)
|
||||
mesg[i] = nrz(CODE::get_le_bit(inp, i));
|
||||
crc1.reset();
|
||||
for (int i = 0; i < data_bits / 8; ++i)
|
||||
crc1(inp[i]);
|
||||
for (int i = 0; i < 32; ++i)
|
||||
mesg[i+data_bits] = nrz((crc1()>>i)&1);
|
||||
polarenc(code, mesg, frozen_bits, code_order);
|
||||
for (int j = 0; j < cons_rows; ++j) {
|
||||
for (int i = 0; i < cons_cols; ++i)
|
||||
fdom[bin(i+code_off)] *=
|
||||
mod_map(code+mod_bits*(cons_cols*j+i));
|
||||
symbol();
|
||||
}
|
||||
for (int i = 0; i < data_bits; ++i)
|
||||
mesg[i] = nrz(CODE::get_le_bit(inp, i));
|
||||
crc.reset();
|
||||
for (int i = 0; i < data_bits / 8; ++i)
|
||||
crc(inp[i]);
|
||||
for (int i = 0; i < 32; ++i)
|
||||
mesg[i+data_bits] = nrz((crc()>>i)&1);
|
||||
polarenc(code, mesg, frozen_4096_2080, code_order);
|
||||
for (int j = 0; j < payload_symbols; ++j) {
|
||||
for (int i = 0; i < subcarrier_count; ++i)
|
||||
fdom[first_subcarrier+i] *=
|
||||
mod_map(code+mod_bits*(subcarrier_count*j+i));
|
||||
symbol();
|
||||
}
|
||||
for (int i = 0; i < symbol_len; ++i)
|
||||
fdom[i] = 0;
|
||||
symbol();
|
||||
std::cerr << "real PAPR: " << DSP::decibel(papr_min.real()) << " .. " << DSP::decibel(papr_max.real()) << " dB" << std::endl;
|
||||
if (pcm->channels() == 2)
|
||||
std::cerr << "imag PAPR: " << DSP::decibel(papr_min.imag()) << " .. " << DSP::decibel(papr_max.imag()) << " dB" << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
long long int base37_encoder(const char *str)
|
||||
{
|
||||
long long int acc = 0;
|
||||
for (char c = *str++; c; c = *str++) {
|
||||
acc *= 37;
|
||||
if (c >= '0' && c <= '9')
|
||||
acc += c - '0' + 1;
|
||||
else if (c >= 'a' && c <= 'z')
|
||||
acc += c - 'a' + 11;
|
||||
else if (c >= 'A' && c <= 'Z')
|
||||
acc += c - 'A' + 11;
|
||||
else if (c != ' ')
|
||||
return -1;
|
||||
}
|
||||
return acc;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if (argc < 6 || argc > 8) {
|
||||
std::cerr << "usage: " << argv[0] << " OUTPUT RATE BITS CHANNELS INPUT [OFFSET] [CALLSIGN]" << std::endl;
|
||||
if (argc != 3) {
|
||||
std::cerr << "usage: " << argv[0] << " OUTPUT INPUT" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
const char *output_name = argv[1];
|
||||
if (output_name[0] == '-' && output_name[1] == 0)
|
||||
output_name = "/dev/stdout";
|
||||
int output_rate = std::atoi(argv[2]);
|
||||
int output_bits = std::atoi(argv[3]);
|
||||
int output_chan = std::atoi(argv[4]);
|
||||
const char *input_name = argv[5];
|
||||
const char *input_name = argv[2];
|
||||
if (input_name[0] == '-' && input_name[1] == 0)
|
||||
input_name = "/dev/stdin";
|
||||
|
||||
int freq_off = output_chan == 1 ? 2000 : 0;
|
||||
if (argc >= 7)
|
||||
freq_off = std::atoi(argv[6]);
|
||||
|
||||
long long int call_sign = base37_encoder("ANONYMOUS");
|
||||
if (argc >= 8)
|
||||
call_sign = base37_encoder(argv[7]);
|
||||
|
||||
if (call_sign <= 0 || call_sign >= 129961739795077L) {
|
||||
std::cerr << "Unsupported call sign." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
const int band_width = 1600;
|
||||
|
||||
if ((output_chan == 1 && freq_off < band_width / 2) || freq_off < band_width / 2 - output_rate / 2 || freq_off > output_rate / 2 - band_width / 2) {
|
||||
std::cerr << "Unsupported frequency offset." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (freq_off % 50) {
|
||||
std::cerr << "Frequency offset must be divisible by 50." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
typedef float value;
|
||||
typedef DSP::Complex<value> cmplx;
|
||||
|
||||
std::ifstream input_file(input_name, std::ios::binary);
|
||||
if (input_file.bad()) {
|
||||
std::cerr << "Couldn't open file \"" << input_name << "\" for reading." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
const int data_len = 1360 / 8;
|
||||
const int data_len = 2048 / 8;
|
||||
uint8_t *input_data = new uint8_t[data_len];
|
||||
for (int i = 0; i < data_len; ++i)
|
||||
input_data[i] = std::max(input_file.get(), 0);
|
||||
int oper_mode = 0;
|
||||
for (int i = 128; i < 170; ++i)
|
||||
if (!oper_mode && input_data[i])
|
||||
oper_mode = 14;
|
||||
for (int i = 85; i < 128; ++i)
|
||||
if (!oper_mode && input_data[i])
|
||||
oper_mode = 15;
|
||||
for (int i = 0; i < 85; ++i)
|
||||
if (!oper_mode && input_data[i])
|
||||
oper_mode = 16;
|
||||
|
||||
CODE::Xorshift32 scrambler;
|
||||
for (int i = 0; i < data_len; ++i)
|
||||
input_data[i] ^= scrambler();
|
||||
|
||||
DSP::WriteWAV<value> output_file(output_name, output_rate, output_bits, output_chan);
|
||||
const int output_rate = 8000;
|
||||
const int output_bits = 16;
|
||||
const int output_chan = 1;
|
||||
DSP::WriteWAV<float> output_file(output_name, output_rate, output_bits, output_chan);
|
||||
output_file.silence(output_rate);
|
||||
switch (output_rate) {
|
||||
case 8000:
|
||||
delete new Encoder<value, cmplx, 8000>(&output_file, input_data, freq_off, call_sign, oper_mode);
|
||||
break;
|
||||
case 16000:
|
||||
delete new Encoder<value, cmplx, 16000>(&output_file, input_data, freq_off, call_sign, oper_mode);
|
||||
break;
|
||||
case 44100:
|
||||
delete new Encoder<value, cmplx, 44100>(&output_file, input_data, freq_off, call_sign, oper_mode);
|
||||
break;
|
||||
case 48000:
|
||||
delete new Encoder<value, cmplx, 48000>(&output_file, input_data, freq_off, call_sign, oper_mode);
|
||||
break;
|
||||
default:
|
||||
std::cerr << "Unsupported sample rate." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
delete new Encoder(&output_file, input_data);
|
||||
output_file.silence(output_rate);
|
||||
delete []input_data;
|
||||
|
||||
|
|
|
|||
|
|
@ -33,8 +33,6 @@ void code(int N, int K)
|
|||
|
||||
int main()
|
||||
{
|
||||
code<11>(2048, 1360+32);
|
||||
code<11>(2048, 1024+32);
|
||||
code<11>(2048, 680+32);
|
||||
code<12>(4096, 2048+32);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1 @@
|
|||
static const uint32_t frozen_2048_1392[64] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0x11f7fff, 0xffffffff, 0x7fffffff, 0x17ffffff, 0x117177f, 0x177f7fff, 0x1037f, 0x1011f, 0x1, 0xffffffff, 0x177fffff, 0x77f7fff, 0x1011f, 0x1173fff, 0x10117, 0x10117, 0x0, 0x117177f, 0x17, 0x3, 0x0, 0x1, 0x0, 0x0, 0x0, 0x7fffffff, 0x11f7fff, 0x11717ff, 0x117, 0x17177f, 0x3, 0x1, 0x0, 0x1037f, 0x1, 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1011f, 0x1, 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
|
||||
static const uint32_t frozen_2048_1056[64] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0xffffffff, 0x177fffff, 0x177f7fff, 0x1017f, 0xffffffff, 0xffffffff, 0xffffffff, 0x177f7fff, 0x7fffffff, 0x13f7fff, 0x1171fff, 0x117, 0x3fffffff, 0x11717ff, 0x7177f, 0x1, 0x1017f, 0x1, 0x1, 0x0, 0xffffffff, 0x7fffffff, 0x7fffffff, 0x1171fff, 0x17ffffff, 0x7177f, 0x1037f, 0x1, 0x77f7fff, 0x1013f, 0x10117, 0x1, 0x10117, 0x0, 0x0, 0x0, 0x1173fff, 0x10117, 0x117, 0x0, 0x7, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
|
||||
static const uint32_t frozen_2048_712[64] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x177fffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0x11f7fff, 0xffffffff, 0x7fffffff, 0x1fffffff, 0x17177f, 0x177fffff, 0x1037f, 0x1011f, 0x1, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0xffffffff, 0x1fffffff, 0x177fffff, 0x1077f, 0xffffffff, 0x177f7fff, 0x13f7fff, 0x10117, 0x1171fff, 0x117, 0x7, 0x0, 0x7fffffff, 0x1173fff, 0x11717ff, 0x7, 0x3077f, 0x1, 0x1, 0x0, 0x1013f, 0x1, 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, };
|
||||
static const uint32_t frozen_4096_2080[128] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x17ffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x77f7fff, 0x7fffffff, 0x1173fff, 0x11717ff, 0x117, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0x11f7fff, 0xffffffff, 0x7fffffff, 0x1fffffff, 0x117177f, 0x177fffff, 0x1077f, 0x1013f, 0x1, 0xffffffff, 0x177fffff, 0x177f7fff, 0x1013f, 0x11f7fff, 0x10117, 0x10117, 0x1, 0x11717ff, 0x117, 0x7, 0x0, 0x1, 0x0, 0x0, 0x0, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff, 0xffffffff, 0x17ffffff, 0x177fffff, 0x1077f, 0xffffffff, 0x177f7fff, 0x11f7fff, 0x10117, 0x11717ff, 0x10117, 0x17, 0x0, 0x7fffffff, 0x1171fff, 0x117177f, 0x17, 0x3177f, 0x1, 0x1, 0x0, 0x1017f, 0x1, 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x177fffff, 0x7177f, 0x1037f, 0x1, 0x1011f, 0x1, 0x1, 0x0, 0x10117, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10117, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue