mirror
/
F5OEO-ft8_lib
kopia lustrzana https://github.com/F5OEO/ft8_lib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Updated decoding to v2

oop-decoder
Karlis Goba 2018-12-24 14:22:26 +02:00
rodzic bff6589f7f
commit e6cbd139ff
13 zmienionych plików z 658 dodań i 285 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

11
Makefile
Wyświetl plik

@ -1,8 +1,7 @@
CXXFLAGS = -std=c++14 -I.
LDFLAGS = -lm
TARGETS = gen_ft8
#TARGETS = gen_ft8 decode_ft8 test
TARGETS = gen_ft8 decode_ft8 test
.PHONY: run_tests all clean
@ -14,11 +13,11 @@ run_tests: test
gen_ft8: gen_ft8.o ft8/constants.o ft8/text.o ft8/pack_v2.o ft8/encode_v2.o common/wave.o
$(CXX) $(LDFLAGS) -o $@ $^
#test: test.o ft8/encode.o ft8/pack.o ft8/text.o ft8/pack_v2.o ft8/encode_v2.o ft8/unpack.o
# $(CXX) $(LDFLAGS) -o $@ $^
test: test.o ft8/v1/encode.o ft8/v1/pack.o ft8/v1/unpack.o ft8/pack_v2.o ft8/encode_v2.o ft8/text.o ft8/constants.o
$(CXX) $(LDFLAGS) -o $@ $^
#decode_ft8: decode_ft8.o fft/kiss_fftr.o fft/kiss_fft.o ft8/ldpc.o ft8/unpack.o ft8/text.o common/wave.o
# $(CXX) $(LDFLAGS) -o $@ $^
decode_ft8: decode_ft8.o fft/kiss_fftr.o fft/kiss_fft.o ft8/ldpc.o ft8/unpack_v2.o ft8/text.o ft8/constants.o common/wave.o
$(CXX) $(LDFLAGS) -o $@ $^
clean:
rm -f *.o ft8/*.o common/*.o fft/*.o $(TARGETS)

132
decode_ft8.cpp
Wyświetl plik

@ -3,16 +3,12 @@
#include <cstdio>
#include <cmath>
#include "common/wave.h"
#include "ft8/pack.h"
#include "ft8/encode.h"
#include "ft8/pack_v2.h"
#include "ft8/encode_v2.h"
#include "ft8/unpack.h"
#include "ft8/unpack_v2.h"
#include "ft8/ldpc.h"
#include "fft/kiss_fftr.h"
#include "ft8/constants.h"
#include "common/wave.h"
#include "fft/kiss_fftr.h"
void usage() {
printf("Decode a 15-second WAV file.\n");
@ -79,11 +75,11 @@ void heapify_up(Candidate * heap, int heap_size) {
// Find top N candidates in frequency and time according to their sync strength (looking at Costas symbols)
// We treat and organize the candidate list as a min-heap (empty initially).
void find_sync(const uint8_t *power, int num_blocks, int num_bins, const uint8_t *sync_map, int num_candidates, Candidate *heap) {
int find_sync(const uint8_t *power, int num_blocks, int num_bins, const uint8_t *sync_map, int num_candidates, Candidate *heap) {
int heap_size = 0;
for (int alt = 0; alt < 4; ++alt) {
for (int time_offset = 0; time_offset < num_blocks - NN; ++time_offset) {
for (int time_offset = 0; time_offset < num_blocks - FT8_NN; ++time_offset) {
for (int freq_offset = 0; freq_offset < num_bins - 8; ++freq_offset) {
int score = 0;
@ -122,6 +118,8 @@ void find_sync(const uint8_t *power, int num_blocks, int num_bins, const uint8_t
}
}
}
return heap_size;
}
@ -134,6 +132,9 @@ void extract_power(const float * signal, int num_blocks, int num_bins, uint8_t *
for (int i = 0; i < nfft; ++i) {
window[i] = hann_i(i, nfft);
}
// for (int i = 0; i < nfft; ++i) {
// window[i] = (i < block_size) ? 2 * hann_i(i, block_size) : 0.0f;
// }
size_t fft_work_size;
kiss_fftr_alloc(nfft, 0, 0, &fft_work_size);
@ -146,6 +147,7 @@ void extract_power(const float * signal, int num_blocks, int num_bins, uint8_t *
int offset = 0;
float fft_norm = 1.0f / nfft;
float max_mag = -100.0f;
for (int i = 0; i < num_blocks; ++i) {
// Loop over two possible time offsets (0 and block_size/2)
for (int time_sub = 0; time_sub <= block_size/2; time_sub += block_size/2) {
@ -162,8 +164,8 @@ void extract_power(const float * signal, int num_blocks, int num_bins, uint8_t *
// Compute log magnitude in decibels
for (int j = 0; j < nfft/2 + 1; ++j) {
float mag2 = fft_norm * (freqdata[j].i * freqdata[j].i + freqdata[j].r * freqdata[j].r);
mag_db[j] = 10.0f * log10f(1.0E-10f + mag2);
float mag2 = (freqdata[j].i * freqdata[j].i + freqdata[j].r * freqdata[j].r);
mag_db[j] = 10.0f * log10f(1.0E-10f + mag2 * fft_norm);
}
// Loop over two possible frequency bin offsets (for averaging)
@ -173,15 +175,19 @@ void extract_power(const float * signal, int num_blocks, int num_bins, uint8_t *
float db2 = mag_db[j * 2 + freq_sub + 1];
float db = (db1 + db2) / 2;
// Scale decibels to unsigned 8-bit range
// Scale decibels to unsigned 8-bit range and clamp the value
int scaled = (int)(2 * (db + 100));
power[offset] = (scaled < 0) ? 0 : ((scaled > 255) ? 255 : scaled);
++offset;
if (db > max_mag) max_mag = db;
}
}
}
}
printf("Max magnitude: %.1f dB\n", max_mag);
free(fft_work);
}
@ -203,7 +209,7 @@ void extract_likelihood(const uint8_t *power, int num_bins, const Candidate & ca
int k = 0;
// Go over FSK tones and skip Costas sync symbols
for (int i = 7; i < NN - 7; ++i) {
for (int i = 7; i < FT8_NN - 7; ++i) {
if (i == 36) i += 7;
// Pointer to 8 bins of the current symbol
@ -222,14 +228,15 @@ void extract_likelihood(const uint8_t *power, int num_bins, const Candidate & ca
// printf("%d %d %d %d %d %d %d %d : %.0f %.0f %.0f\n",
// ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6], ps[7],
// log174[k + 0], log174[k + 1], log174[k + 2]);
k += 3;
}
// Compute the variance of log174
float sum = 0;
float sum2 = 0;
float inv_n = 1.0f / (3 * ND);
for (int i = 0; i < 3 * ND; ++i) {
float inv_n = 1.0f / (3 * FT8_ND);
for (int i = 0; i < 3 * FT8_ND; ++i) {
sum += log174[i];
sum2 += log174[i] * log174[i];
}
@ -238,7 +245,7 @@ void extract_likelihood(const uint8_t *power, int num_bins, const Candidate & ca
// Normalize log174 such that sigma = 2.83 (Why? It's in WSJT-X)
float norm_factor = 2.83f / sqrtf(variance);
for (int i = 0; i < 3 * ND; ++i) {
for (int i = 0; i < 3 * FT8_ND; ++i) {
log174[i] *= norm_factor;
//printf("%.1f ", log174[i]);
}
@ -246,6 +253,35 @@ void extract_likelihood(const uint8_t *power, int num_bins, const Candidate & ca
}
void test_tones(float *log174) {
for (int i = 0; i < FT8_ND; ++i) {
const uint8_t inv_map[8] = {0, 1, 3, 2, 6, 4, 5, 7};
uint8_t tone = ("0000000011721762454112705354533170166234757420515470163426"[i]) - '0';
uint8_t b3 = inv_map[tone];
log174[3 * i] = (b3 & 4) ? +1.0 : -1.0;
log174[3 * i + 1] = (b3 & 2) ? +1.0 : -1.0;
log174[3 * i + 2] = (b3 & 1) ? +1.0 : -1.0;
}
// 3140652 00000000117217624541127053545 3140652 33170166234757420515470163426 3140652
// 0000000011721762454112705354533170166234757420515470163426
// 0000000011721762454112705454544170166344757430515470073537
// 0000000011711761444111704343433170166233747320414370072427
// 0000000011711761454111705353533170166233757320515370072527
}
void print_tones(const uint8_t *code_map, const float *log174) {
for (int k = 0; k < 3 * FT8_ND; k += 3) {
uint8_t max = 0;
if (log174[k + 0] > 0) max |= 4;
if (log174[k + 1] > 0) max |= 2;
if (log174[k + 2] > 0) max |= 1;
printf("%d", code_map[max]);
}
printf("\n");
}
int main(int argc, char ** argv) {
// Expect one command-line argument
if (argc < 2) {
@ -264,13 +300,6 @@ int main(int argc, char ** argv) {
return -1;
}
// Costas 7x7 tone pattern
const uint8_t kCostas_map_v1[] = { 2,5,6,0,4,1,3 };
const uint8_t kCostas_map_v2[] = { 3,1,4,0,6,5,2 };
// Gray maps (used only in v2)
const uint8_t kGray_map_v1[8] = { 0,1,2,3,4,5,6,7 }; // identity map
const uint8_t kGray_map_v2[8] = { 0,1,3,2,5,6,4,7 };
const float fsk_dev = 6.25f;
const int num_bins = (int)(sample_rate / (2 * fsk_dev));
@ -282,41 +311,45 @@ int main(int argc, char ** argv) {
extract_power(signal, num_blocks, num_bins, power);
int num_candidates = 250;
int num_candidates = 100;
Candidate heap[num_candidates];
find_sync(power, num_blocks, num_bins, kCostas_map_v1, num_candidates, heap);
find_sync(power, num_blocks, num_bins, kCostas_map, num_candidates, heap);
for (int idx = 0; idx < num_candidates; ++idx) {
Candidate &cand = heap[idx];
float log174[3 * ND];
extract_likelihood(power, num_bins, cand, kGray_map_v1, log174);
float log174[3 * FT8_ND];
extract_likelihood(power, num_bins, cand, kGray_map, log174);
const int num_iters = 20;
int plain[3 * ND];
int ok = 0;
const int num_iters = 25;
uint8_t plain[3 * FT8_ND];
int n_errors = 0;
bp_decode(log174, num_iters, plain, &ok);
//ldpc_decode(log174, num_iters, plain, &ok);
//printf("ldpc_decode() = %d\n", ok);
if (ok == 87) {
float freq_hz = (cand.freq_offset + cand.freq_sub / 2.0f) * fsk_dev;
float time_sec = (cand.time_offset + cand.time_sub / 2.0f) / fsk_dev;
//printf("%03d: score = %d freq = %.1f time = %.2f\n", idx,
// cand.score, freq_hz, time_sec);
uint8_t a87[11];
printf("%03d: score = %d freq = %.1f time = %.2f\n", idx,
cand.score, freq_hz, time_sec);
bp_decode(log174, num_iters, plain, &n_errors);
//ldpc_decode(log174, num_iters, plain, &n_errors);
printf("ldpc_decode() = %d\n", n_errors);
if (n_errors == 0) {
//print_tones(kGray_map, log174);
// Extract payload + CRC
uint8_t a91[12];
uint8_t mask = 0x80;
uint8_t position = 0;
for (int i = 0; i < 11; ++i) {
a87[i] = 0;
for (int i = 0; i < 12; ++i) {
a91[i] = 0;
}
// Extract payload + CRC (last 87 bits)
for (int i = 174 - 87; i < 174; ++i) {
for (int i = 0; i < FT8_K; ++i) {
if (plain[i]) {
a87[position] |= mask;
a91[position] |= mask;
}
mask >>= 1;
if (!mask) {
@ -325,14 +358,17 @@ int main(int argc, char ** argv) {
}
}
for (int i = 0; i < 11; ++i) {
//printf("%02x ", a87[i]);
}
// TODO: check CRC
// for (int i = 0; i < 12; ++i) {
// printf("%02x ", a91[i]);
// }
// printf("\n");
char message[20];
unpack(a87, message);
unpack77(a91, message);
// Fake WSJT-X-like output for now
printf("000000 0 %4.1f %4d ~ %s\n", time_sec, (int)(freq_hz + 0.5f), message);
}
}

371
ft8/ldpc.cpp
Wyświetl plik

@ -14,9 +14,190 @@
#include <stdlib.h>
#include "constants.h"
int ldpc_check(int codeword[]);
int ldpc_check(uint8_t codeword[]);
float fast_tanh(float x);
float fast_atanh(float x);
// codeword is 174 log-likelihoods.
// plain is a return value, 174 ints, to be 0 or 1.
// max_iters is how hard to try.
// ok == 87 means success.
void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
float m[FT8_M][FT8_N]; // ~60 kB
float e[FT8_M][FT8_N]; // ~60 kB
int min_errors = FT8_M;
for (int j = 0; j < FT8_M; j++) {
for (int i = 0; i < FT8_N; i++) {
m[j][i] = codeword[i];
e[j][i] = 0.0f;
}
}
for (int iter = 0; iter < max_iters; iter++) {
for (int j = 0; j < FT8_M; j++) {
for (int ii1 = 0; ii1 < kNrw[j]; ii1++) {
int i1 = kNm[j][ii1] - 1;
float a = 1.0f;
for (int ii2 = 0; ii2 < kNrw[j]; ii2++) {
int i2 = kNm[j][ii2] - 1;
if (i2 != i1) {
a *= fast_tanh(-m[j][i2] / 2.0f);
}
}
e[j][i1] = logf((1 - a) / (1 + a));
}
}
uint8_t cw[FT8_N];
for (int i = 0; i < FT8_N; i++) {
float l = codeword[i];
for (int j = 0; j < 3; j++)
l += e[kMn[i][j] - 1][i];
cw[i] = (l > 0) ? 1 : 0;
}
int errors = ldpc_check(cw);
if (errors < min_errors) {
// Update the current best result
for (int i = 0; i < FT8_N; i++) {
plain[i] = cw[i];
}
min_errors = errors;
if (errors == 0) {
break; // Found a perfect answer
}
}
for (int i = 0; i < FT8_N; i++) {
for (int ji1 = 0; ji1 < 3; ji1++) {
int j1 = kMn[i][ji1] - 1;
float l = codeword[i];
for (int ji2 = 0; ji2 < 3; ji2++) {
if (ji1 != ji2) {
int j2 = kMn[i][ji2] - 1;
l += e[j2][i];
}
}
m[j1][i] = l;
}
}
}
*ok = min_errors;
}
//
// does a 174-bit codeword pass the FT8's LDPC parity checks?
// returns the number of parity errors.
// 0 means total success.
//
int ldpc_check(uint8_t codeword[]) {
int errors = 0;
// kNm[87][7]
for (int j = 0; j < FT8_M; ++j) {
uint8_t x = 0;
for (int ii1 = 0; ii1 < kNrw[j]; ++ii1) {
x ^= codeword[kNm[j][ii1] - 1];
}
if (x != 0) {
++errors;
}
}
return errors;
}
void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
float tov[FT8_N][3];
float toc[FT8_M][7];
int min_errors = FT8_M;
int nclast = 0;
int ncnt = 0;
// initialize messages to checks
for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) {
toc[i][j] = codeword[kNm[i][j] - 1];
}
}
for (int i = 0; i < FT8_N; ++i) {
for (int j = 0; j < 3; ++j) {
tov[i][j] = 0;
}
}
for (int iter = 0; iter < max_iters; ++iter) {
float zn[FT8_N];
uint8_t cw[FT8_N];
// Update bit log likelihood ratios (tov=0 in iter 0)
for (int i = 0; i < FT8_N; ++i) {
zn[i] = codeword[i] + tov[i][0] + tov[i][1] + tov[i][2];
cw[i] = (zn[i] > 0) ? 1 : 0;
}
// Check to see if we have a codeword (check before we do any iter)
int errors = ldpc_check(cw);
if (errors < min_errors) {
// we have a better guess - update the result
for (int i = 0; i < FT8_N; i++) {
plain[i] = cw[i];
}
min_errors = errors;
if (errors == FT8_M) {
break; // Found a perfect answer
}
}
// Send messages from bits to check nodes
for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) {
int ibj = kNm[i][j] - 1;
toc[i][j] = zn[ibj];
for (int kk = 0; kk < 3; ++kk) {
// subtract off what the bit had received from the check
if (kMn[ibj][kk] - 1 == i) {
toc[i][j] -= tov[ibj][kk];
}
}
}
}
// send messages from check nodes to variable nodes
for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) {
toc[i][j] = fast_tanh(-toc[i][j] / 2);
}
}
for (int i = 0; i < FT8_N; ++i) {
for (int j = 0; j < 3; ++j) {
int ichk = kMn[i][j] - 1; // kMn(:,j) are the checks that include bit j
float Tmn = 1.0f;
for (int k = 0; k < kNrw[ichk]; ++k) {
if (kNm[ichk][k] - 1 != i) {
Tmn *= toc[ichk][k];
}
}
tov[i][j] = 2 * fast_atanh(-Tmn);
}
}
}
*ok = min_errors;
}
// https://varietyofsound.wordpress.com/2011/02/14/efficient-tanh-computation-using-lamberts-continued-fraction/
// http://functions.wolfram.com/ElementaryFunctions/ArcTanh/10/0001/
// https://mathr.co.uk/blog/2017-09-06_approximating_hyperbolic_tangent.html
@ -96,191 +277,3 @@ float platanh(float x) {
}
return isign * 7.0f;
}
// codeword is 174 log-likelihoods.
// plain is a return value, 174 ints, to be 0 or 1.
// max_iters is how hard to try.
// ok == 87 means success.
void ldpc_decode(float codeword[], int max_iters, int plain[], int *ok) {
float m[FT8_M][FT8_N]; // ~60 kB
float e[FT8_M][FT8_N]; // ~60 kB
int best_score = -1;
for (int j = 0; j < FT8_M; j++) {
for (int i = 0; i < FT8_N; i++) {
m[j][i] = codeword[i];
e[j][i] = 0.0f;
}
}
for (int iter = 0; iter < max_iters; iter++) {
for (int j = 0; j < FT8_M; j++) {
for (int ii1 = 0; ii1 < kNrw[j]; ii1++) {
int i1 = kNm[j][ii1] - 1;
float a = 1.0f;
for (int ii2 = 0; ii2 < kNrw[j]; ii2++) {
int i2 = kNm[j][ii2] - 1;
if (i2 != i1) {
a *= fast_tanh(-m[j][i2] / 2.0f);
}
}
e[j][i1] = logf((1 - a) / (1 + a));
}
}
int cw[FT8_N];
for (int i = 0; i < FT8_N; i++) {
float l = codeword[i];
for (int j = 0; j < 3; j++)
l += e[kMn[i][j] - 1][i];
cw[i] = (l > 0) ? 1 : 0;
}
int score = ldpc_check(cw);
if (score > best_score) {
// Update the current best result
for (int i = 0; i < FT8_N; i++) {
//plain[i] = cw[colorder[i]]; // Reverse the column permutation
plain[i] = cw[i];
}
best_score = score;
if (score == FT8_M) {
// Found a perfect answer
break;
}
}
for (int i = 0; i < FT8_N; i++) {
for (int ji1 = 0; ji1 < 3; ji1++) {
int j1 = kMn[i][ji1] - 1;
float l = codeword[i];
for (int ji2 = 0; ji2 < 3; ji2++) {
if (ji1 != ji2) {
int j2 = kMn[i][ji2] - 1;
l += e[j2][i];
}
}
m[j1][i] = l;
}
}
}
*ok = best_score;
}
//
// does a 174-bit codeword pass the FT8's LDPC parity checks?
// returns the number of parity checks that passed.
// 87 means total success.
//
int ldpc_check(int codeword[]) {
int score = 0;
// kNm[87][7]
for (int j = 0; j < FT8_M; ++j) {
int x = 0;
for (int ii1 = 0; ii1 < kNrw[j]; ++ii1) {
x ^= codeword[kNm[j][ii1] - 1];
}
if (x == 0) {
++score;
}
}
return score;
}
void bp_decode(float codeword[], int max_iters, int plain[], int *ok) {
float tov[FT8_N][3];
float toc[FT8_M][7];
int best_score = -1;
int nclast = 0;
int ncnt = 0;
// initialize messages to checks
for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) {
toc[i][j] = codeword[kNm[i][j] - 1];
}
}
for (int i = 0; i < FT8_N; ++i) {
for (int j = 0; j < 3; ++j) {
tov[i][j] = 0;
}
}
for (int iter = 0; iter < max_iters; ++iter) {
float zn[FT8_N];
int cw[FT8_N];
// Update bit log likelihood ratios (tov=0 in iter 0)
for (int i = 0; i < FT8_N; ++i) {
zn[i] = codeword[i] + tov[i][0] + tov[i][1] + tov[i][2];
cw[i] = (zn[i] > 0) ? 1 : 0;
}
// Check to see if we have a codeword (check before we do any iter)
int score = ldpc_check(cw);
if (score > best_score) {
// we have a better guess - update the result
for (int i = 0; i < FT8_N; i++) {
//plain[i] = cw[colorder[i]]; // Reverse the column permutation
plain[i] = cw[i];
}
best_score = score;
if (score == FT8_M) {
break;
}
}
// Send messages from bits to check nodes
for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) {
int ibj = kNm[i][j] - 1;
toc[i][j] = zn[ibj];
for (int kk = 0; kk < 3; ++kk) {
// subtract off what the bit had received from the check
if (kMn[ibj][kk] - 1 == i) {
toc[i][j] -= tov[ibj][kk];
}
}
}
}
// send messages from check nodes to variable nodes
for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) {
//toc[i][j] = pltanh(-toc[i][j] / 2);
toc[i][j] = fast_tanh(-toc[i][j] / 2);
//toc[i][j] = tanhf(-toc[i][j] / 2);
}
}
for (int i = 0; i < FT8_N; ++i) {
for (int j = 0; j < 3; ++j) {
int ichk = kMn[i][j] - 1; // kMn(:,j) are the checks that include bit j
float Tmn = 1.0f;
for (int k = 0; k < kNrw[ichk]; ++k) {
if (kNm[ichk][k] - 1 != i) {
Tmn *= toc[ichk][k];
}
}
//tov[i][j] = 2 * platanh(-Tmn);
tov[i][j] = 2 * fast_atanh(-Tmn);
//tov[i][j] = 2 * atanhf(-Tmn);
}
}
}
*ok = best_score;
}

4
ft8/ldpc.h
Wyświetl plik

@ -4,6 +4,6 @@
// plain is a return value, 174 ints, to be 0 or 1.
// iters is how hard to try.
// ok == 87 means success.
void ldpc_decode(float codeword[], int max_iters, int plain[], int *ok);
void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok);
void bp_decode(float codeword[], int max_iters, int plain[], int *ok);
void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok);

62
ft8/pack_v2.cpp
Wyświetl plik

@ -9,11 +9,12 @@
namespace ft8_v2 {
// TODO: This is wasteful, should figure out something more elegant
const char *A0 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
const char *A1 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *A2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *A3 = "0123456789";
const char *A4 = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char A0[] = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
const char A1[] = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char A2[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char A3[] = "0123456789";
const char A4[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int index(const char *string, char c) {
for (int i = 0; *string; ++i, ++string) {
@ -24,6 +25,7 @@ int index(const char *string, char c) {
return -1; // Not found
}
// Pack a special token, a 22-bit hash code, or a valid base call
// into a 28-bit integer.
int32_t pack28(const char *callsign) {
@ -44,8 +46,8 @@ int32_t pack28(const char *callsign) {
}
// TODO: Check for <...> callsign
// if(c13(1:1).eq.'<')then
// call save_hash_call(c13,n10,n12,n22) !Save callsign in hash table
// if(text(1:1).eq.'<')then
// call save_hash_call(text,n10,n12,n22) !Save callsign in hash table
// n28=NTOKENS + n22
char c6[6] = {' ', ' ', ' ', ' ', ' ', ' '};
@ -55,21 +57,24 @@ int32_t pack28(const char *callsign) {
length++;
}
// Work-around for Swaziland prefix:
// Copy callsign to 6 character buffer
if (starts_with(callsign, "3DA0") && length <= 7) {
// Work-around for Swaziland prefix: 3DA0XYZ -> 3D0XYZ
memcpy(c6, "3D0", 3);
memcpy(c6 + 3, callsign + 4, length - 4);
}
// Work-around for Guinea prefixes:
else if (starts_with(callsign, "3X") && is_letter(callsign[2]) && length <= 7) {
// Work-around for Guinea prefixes: 3XA0XYZ -> QA0XYZ
memcpy(c6, "Q", 1);
memcpy(c6 + 1, callsign + 2, length - 2);
}
else {
if (is_digit(callsign[2]) && length <= 6) {
// AB0XYZ
memcpy(c6, callsign, length);
}
else if (is_digit(callsign[1]) && length <= 5) {
// A0XYZ -> " A0XYZ"
memcpy(c6 + 1, callsign, length);
}
}
@ -80,7 +85,7 @@ int32_t pack28(const char *callsign) {
(i2 = index(A3, c6[2])) >= 0 && (i3 = index(A4, c6[3])) >= 0 &&
(i4 = index(A4, c6[4])) >= 0 && (i5 = index(A4, c6[5])) >= 0)
{
printf("Pack28: idx=[%d, %d, %d, %d, %d, %d]\n", i0, i1, i2, i3, i4, i5);
//printf("Pack28: idx=[%d, %d, %d, %d, %d, %d]\n", i0, i1, i2, i3, i4, i5);
// This is a standard callsign
int32_t n28 = i0;
n28 = n28 * 36 + i1;
@ -88,17 +93,17 @@ int32_t pack28(const char *callsign) {
n28 = n28 * 27 + i3;
n28 = n28 * 27 + i4;
n28 = n28 * 27 + i5;
printf("Pack28: n28=%d (%04xh)\n", n28, n28);
//printf("Pack28: n28=%d (%04xh)\n", n28, n28);
return NTOKENS + MAX22 + n28;
}
//char c13[13];
//char text[13];
//if (length > 13) return -1;
// TODO:
// Treat this as a nonstandard callsign: compute its 22-bit hash
// call save_hash_call(c13,n10,n12,n22) !Save callsign in hash table
// call save_hash_call(text,n10,n12,n22) !Save callsign in hash table
// n28=NTOKENS + n22
// n28=iand(n28,ishft(1,28)-1)
@ -213,10 +218,6 @@ int pack77_1(const char *msg, uint8_t *b77) {
// write(c77,1000) n28a,ipa,n28b,ipb,ir,igrid4,i3
// 1000 format(2(b28.28,b1),b1,b15.15,b3.3)
// 00 00 00 27 b3 00 01 0b 27 8f b9 e0
// (00 00 00 2) 0 (f0 85 ab e) (0)
// 7842D5F
b77[0] = (n28a >> 21);
b77[1] = (n28a >> 13);
b77[2] = (n28a >> 5);
@ -232,30 +233,43 @@ int pack77_1(const char *msg, uint8_t *b77) {
}
void packtext77(const char *c13, uint8_t *b71) {
// TODO: w=adjustr(c13)
void packtext77(const char *text, uint8_t *b71) {
int length = strlen(text);
// Skip leading and trailing spaces
while (*text == ' ' && *text != 0) {
++text;
--length;
}
while (length > 0 && text[length - 1] == ' ') {
--length;
}
for (int i = 0; i < 9; ++i) {
b71[i] = 0;
}
for (int j = 0; j < 13; ++j) {
int q = index(A0, c13[j]);
// Multiply b71 by 42
// Multiply the long integer in b71 by 42
uint16_t x = 0;
for (int i = 8; i >= 0; --i) {
x += b71[i] * (uint16_t)42;
b71[i] = x;
b71[i] = (x & 0xFF);
x >>= 8;
}
// Add index of the current char
if (j < length) {
int q = index(A0, text[j]);
x = (q > 0) ? q : 0;
}
else {
x = 0;
}
for (int i = 8; i >= 0; --i) {
if (x == 0) break;
x += b71[i];
b71[i] = x;
b71[i] = (x & 0xFF);
x >>= 8;
}
}

4
ft8/text.cpp
Wyświetl plik

@ -78,13 +78,13 @@ int dd_to_int(const char *str, int length) {
// Convert a 2 digit integer to string
void int_to_dd(char *str, int value, int width) {
void int_to_dd(char *str, int value, int width, bool full_sign) {
if (value < 0) {
*str = '-';
++str;
value = -value;
}
else {
else if (full_sign) {
*str = '+';
++str;
}

2
ft8/text.h
Wyświetl plik

@ -17,4 +17,4 @@ void fmtmsg(char *msg_out, const char *msg_in);
int dd_to_int(const char *str, int length);
// Convert a 2 digit integer to string
void int_to_dd(char *str, int value, int width);
void int_to_dd(char *str, int value, int width, bool full_sign = false);

322
ft8/unpack_v2.cpp 100644
Wyświetl plik

@ -0,0 +1,322 @@
#include "unpack_v2.h"
#include "text.h"
#include <string.h>
//const uint32_t NBASE = 37L*36L*10L*27L*27L*27L;
const uint32_t MAX22 = 4194304L;
const uint32_t NTOKENS = 2063592L;
const uint16_t MAXGRID4 = 32400L;
// convert integer index to ASCII character according to one of 5 tables:
// table 0: " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?"
// table 1: " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
// table 2: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
// table 3: "0123456789"
// table 4: " ABCDEFGHIJKLMNOPQRSTUVWXYZ"
char charn(int c, int table_idx) {
if (table_idx == 0 || table_idx == 1 || table_idx == 4) {
if (c == 0) return ' ';
c -= 1;
}
if (table_idx != 4) {
if (c < 10) return '0' + c;
c -= 10;
}
if (table_idx != 3) {
if (c < 26) return 'A' + c;
c -= 26;
}
if (table_idx == 0) {
if (c < 5) return "+-./?" [c];
}
return '_'; // unknown character, should never get here
}
// n28 is a 28-bit integer, e.g. n28a or n28b, containing all the
// call sign bits from a packed message.
int unpack28(uint32_t n28, char *result) {
// Check for special tokens DE, QRZ, CQ, CQ_nnn, CQ_aaaa
if (n28 < NTOKENS) {
if (n28 <= 2) {
if (n28 == 0) strcpy(result, "DE");
if (n28 == 1) strcpy(result, "QRZ");
if (n28 == 2) strcpy(result, "CQ");
return 0; // Success
}
if (n28 <= 1002) {
// CQ_nnn with 3 digits
strcpy(result, "CQ ");
int_to_dd(result + 3, n28 - 3, 3);
return 0; // Success
}
if (n28 <= 532443L) {
// CQ_aaaa with 4 alphanumeric symbols
uint32_t n = n28 - 1003;
char aaaa[5];
aaaa[4] = '\0';
aaaa[3] = charn(n % 27, 4);
n /= 27;
aaaa[2] = charn(n % 27, 4);
n /= 27;
aaaa[1] = charn(n % 27, 4);
n /= 27;
aaaa[0] = charn(n % 27, 4);
// Skip leading whitespace
int ws_len = 0;
while (aaaa[ws_len] == ' ') {
ws_len++;
}
strcpy(result, "CQ ");
strcat(result, aaaa + ws_len);
return 0; // Success
}
// ? TODO: unspecified in the WSJT-X code
return -1;
}
n28 = n28 - NTOKENS;
if (n28 < MAX22) {
// This is a 22-bit hash of a result
//n22=n28
//call hash22(n22,c13) !Retrieve result from hash table
// TODO: implement
return -2;
}
// Standard callsign
uint32_t n = n28 - MAX22;
char callsign[7];
callsign[6] = '\0';
callsign[5] = charn(n % 27, 4);
n /= 27;
callsign[4] = charn(n % 27, 4);
n /= 27;
callsign[3] = charn(n % 27, 4);
n /= 27;
callsign[2] = charn(n % 10, 3);
n /= 10;
callsign[1] = charn(n % 36, 2);
n /= 36;
callsign[0] = charn(n % 37, 1);
// Skip trailing and leading whitespace in case of a short callsign
int ws_len = 0;
while (ws_len <= 5 && callsign[5 - ws_len] == ' ') {
callsign[5 - ws_len] = '\0';
ws_len++;
}
ws_len = 0;
while (callsign[ws_len] == ' ') {
ws_len++;
}
strcpy(result, callsign + ws_len);
return 0; // Success
}
int unpack_type1(const uint8_t *a77, uint8_t i3, char *message) {
uint32_t n28a, n28b;
uint16_t igrid4;
uint8_t ir;
// Extract packed fields
// read(c77,1000) n28a,ipa,n28b,ipb,ir,igrid4,i3
// 1000 format(2(b28,b1),b1,b15,b3)
n28a = (a77[0] << 21);
n28a |= (a77[1] << 13);
n28a |= (a77[2] << 5);
n28a |= (a77[3] >> 3);
n28b = ((a77[3] & 0x07) << 26);
n28b |= (a77[4] << 18);
n28b |= (a77[5] << 10);
n28b |= (a77[6] << 2);
n28b |= (a77[7] >> 6);
ir = ((a77[7] & 0x20) >> 5);
igrid4 = ((a77[7] & 0x1F) << 10);
igrid4 |= (a77[8] << 2);
igrid4 |= (a77[9] >> 6);
// Unpack both callsigns
char field_1[14];
char field_2[14];
if (unpack28(n28a >> 1, field_1) < 0) {
return -1;
}
if (unpack28(n28b >> 1, field_2) < 0) {
return -2;
}
// Fix "CQ_" to "CQ " -> already done in unpack28()
// if (starts_with(field_1, "CQ_")) {
// field_1[2] = ' ';
// }
// Append first two fields to the result
strcpy(message, field_1);
strcat(message, " ");
strcat(message, field_2);
// TODO: add /P and /R suffixes
// if(index(field_1,'<').le.0) then
// ws_len=index(field_1,' ')
// if(ws_len.ge.4 .and. ipa.eq.1 .and. i3.eq.1) field_1(ws_len:ws_len+1)='/R'
// if(ws_len.ge.4 .and. ipa.eq.1 .and. i3.eq.2) field_1(ws_len:ws_len+1)='/P'
// if(ws_len.ge.4) call add_call_to_recent_calls(field_1)
// endif
// if(index(field_2,'<').le.0) then
// ws_len=index(field_2,' ')
// if(ws_len.ge.4 .and. ipb.eq.1 .and. i3.eq.1) field_2(ws_len:ws_len+1)='/R'
// if(ws_len.ge.4 .and. ipb.eq.1 .and. i3.eq.2) field_2(ws_len:ws_len+1)='/P'
// if(ws_len.ge.4) call add_call_to_recent_calls(field_2)
// endif
char field_3[5];
if (igrid4 <= MAXGRID4) {
// Extract 4 symbol grid locator
field_3[4] = '\0';
uint16_t n = igrid4;
field_3[3] = '0' + (n % 10);
n /= 10;
field_3[2] = '0' + (n % 10);
n /= 10;
field_3[1] = 'A' + (n % 18);
n /= 18;
field_3[0] = 'A' + (n % 18);
if (ir != 0) {
// In case of ir=1 add an " R " before grid
strcat(message, " R ");
}
}
else {
// Extract report
int irpt = igrid4 - MAXGRID4;
// Check special cases first
if (irpt == 1) field_3[0] = '\0';
else if (irpt == 2) strcpy(field_3, "RRR");
else if (irpt == 3) strcpy(field_3, "RR73");
else if (irpt == 4) strcpy(field_3, "73");
else if (irpt >= 5) {
// Extract signal report as a two digit number with a + or - sign
if (ir == 0) {
int_to_dd(field_3, irpt - 35, 2, true);
}
else {
field_3[0] = 'R';
int_to_dd(field_3 + 1, irpt - 35, 2, true);
}
}
}
// Append the last field to the result
if (strlen(field_3) > 0) {
strcat(message, " ");
strcat(message, field_3);
}
return 0; // Success
}
int unpack_text(const uint8_t *a71, char *text) {
// TODO: test
uint8_t b71[9];
for (int i = 0; i < 9; ++i) {
b71[i] = a71[i];
}
for (int idx = 0; idx < 13; ++idx) {
// Divide the long integer in b71 by 42
uint16_t rem = 0;
for (int i = 8; i >= 0; --i) {
rem = (rem << 8) | b71[i];
b71[i] = rem / 42;
rem = rem % 42;
}
text[idx] = charn(rem, 0);
}
text[13] = '\0';
return 0; // Success
}
int unpack_telemetry(const uint8_t *a71, char *telemetry) {
uint8_t b71[9];
// Shift bits in a71 right by 1
uint8_t carry = 0;
for (int i = 0; i < 9; ++i) {
b71[i] = (carry << 7) | (a71[i] >> 1);
carry = (a71[i] & 0x01);
}
// Convert b71 to hexadecimal string
for (int i = 0; i < 9; ++i) {
uint8_t nibble1 = (b71[i] >> 4);
uint8_t nibble2 = (b71[i] & 0x0F);
char c1 = (nibble1 > 9) ? (nibble1 - 10 + 'A') : nibble1 + '0';
char c2 = (nibble2 > 9) ? (nibble2 - 10 + 'A') : nibble2 + '0';
telemetry[i * 2] = c1;
telemetry[i * 2 + 1] = c2;
}
telemetry[18] = '\0';
return 0;
}
int unpack77(const uint8_t *a77, char *message) {
uint8_t n3, i3;
n3 = (a77[9] >> 6) & 0x07;
i3 = (a77[9] >> 3) & 0x07;
if (i3 == 0 && n3 == 0) {
// 0.0 Free text
return unpack_text(a77, message);
}
else if (i3 == 0 && n3 == 1) {
// 0.1 K1ABC RR73; W9XYZ <KH1/KH7Z> -11 28 28 10 5 71 DXpedition Mode
}
else if (i3 == 0 && n3 == 2) {
// 0.2 PA3XYZ/P R 590003 IO91NP 28 1 1 3 12 25 70 EU VHF contest
}
else if (i3 == 0 && (n3 == 3 || n3 == 4)) {
// 0.3 WA9XYZ KA1ABC R 16A EMA 28 28 1 4 3 7 71 ARRL Field Day
// 0.4 WA9XYZ KA1ABC R 32A EMA 28 28 1 4 3 7 71 ARRL Field Day
}
else if (i3 == 0 && n3 == 5) {
// 0.5 0123456789abcdef01 71 71 Telemetry (18 hex)
return unpack_telemetry(a77, message);
}
else if (i3 == 1 || i3 == 2) {
// Type 1 (standard message) or Type 2 ("/P" form for EU VHF contest)
return unpack_type1(a77, i3, message);
}
else if (i3 == 3) {
// Type 3: ARRL RTTY Contest
}
else if (i3 == 4) {
// Type 4: Nonstandard calls, e.g. <WA9XYZ> PJ4/KA1ABC RR73
// One hashed call or "CQ"; one compound or nonstandard call with up
// to 11 characters; and (if not "CQ") an optional RRR, RR73, or 73.
// TODO: implement
// read(c77,1050) n12,n58,iflip,nrpt,icq
// 1050 format(b12,b58,b1,b2,b1)
}
return 0;
}

7
ft8/unpack_v2.h 100644
Wyświetl plik

@ -0,0 +1,7 @@
#pragma once
#include <stdint.h>
// message should have at least 19 bytes allocated (18 characters + zero terminator)
int unpack77(const uint8_t *a77, char *message);

2
ft8/v1/pack.cpp
Wyświetl plik

@ -2,7 +2,7 @@
#include <cstdio>
#include "pack.h"
#include "text.h"
#include "../text.h"
constexpr int32_t NBASE = 37*36*10*27*27*27L;
constexpr int32_t NGBASE = 180*180L;

2
ft8/v1/unpack.cpp
Wyświetl plik

@ -1,5 +1,5 @@
#include "unpack.h"
#include "text.h"
#include "../text.h"
#include <string.h>

10
gen_ft8.cpp
Wyświetl plik

@ -84,15 +84,17 @@ int main(int argc, char **argv) {
printf("\n");
// Third, convert the FSK tones into an audio signal
const int num_samples = (int)(0.5 + FT8_NN / 6.25 * 12000);
const int num_silence = (15 * 12000 - num_samples) / 2;
const int sample_rate = 12000;
const float symbol_rate = 6.25f;
const int num_samples = (int)(0.5f + FT8_NN / symbol_rate * sample_rate);
const int num_silence = (15 * sample_rate - num_samples) / 2;
float signal[num_silence + num_samples + num_silence];
for (int i = 0; i < num_silence + num_samples + num_silence; i++) {
signal[i] = 0;
}
synth_fsk(tones, FT8_NN, 1000, 6.25, 6.25, 12000, signal + num_silence);
save_wav(signal, num_silence + num_samples + num_silence, 12000, wav_path);
synth_fsk(tones, FT8_NN, 1000, symbol_rate, symbol_rate, sample_rate, signal + num_silence);
save_wav(signal, num_silence + num_samples + num_silence, sample_rate, wav_path);
return 0;
}

6
test.cpp
Wyświetl plik

@ -4,11 +4,11 @@
#include <cmath>
#include "ft8/text.h"
#include "ft8/pack.h"
#include "ft8/v1/pack.h"
#include "ft8/v1/unpack.h"
#include "ft8/v1/encode.h"
#include "ft8/pack_v2.h"
#include "ft8/encode.h"
#include "ft8/encode_v2.h"
#include "ft8/unpack.h"
#include "common/debug.h"