Olivia.h

Go to the documentation of this file.

#pragma once
 
#include <ctype.h>
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
#include "AudioTools.h"
#include "DSPUtils.h"
 
namespace tinymodem {

struct OliviaConfig : public audio_tools::AudioInfo {
  OliviaConfig() {
    sample_rate = 48000;
    channels = 1;
    bits_per_sample = 16;
  }

  int tones = 32;
  int bandwidth = 1000;
  float center_freq = 1500.0f;
  bool contestia = false;
  float volume = 1.0f;
  bool start_tones = true;
  int sync_margin = 8;
  int sync_integration = 4;
  float sync_threshold = 3.0f;
  bool rx_one = false;
  uint8_t channel = 0;
  float rx_noise = 0.0f;

  static constexpr float BASE_RATE = 8000.0f;

  bool setMode(const char* mode) {
    int t, b;
    bool c;
    if (!parseMode(mode, t, b, c)) return false;
    tones = t;
    bandwidth = b;
    contestia = c;
    return true;
  }

  static bool isMode(const char* mode) {
    int t, b;
    bool c;
    return parseMode(mode, t, b, c);
  }

  int bitsPerSymbol() const {
    int bits = 0;
    while ((1 << (bits + 1)) <= tones) bits++;
    return bits;
  }

  int symbolLen() const {
    int bw = 0;
    while ((125 << (bw + 1)) <= bandwidth) bw++;
    return 1 << (bitsPerSymbol() + 7 - bw);
  }

  int symbolSepar() const { return symbolLen() / 2; }

  int symbolsPerBlock() const { return contestia ? 32 : 64; }

  int bitsPerCharacter() const { return contestia ? 6 : 7; }

  int firstCarrier() const {
    double offset = contestia ? bandwidth / 2.0
                              : bandwidth * (1.0 - 0.5 / tones) / 2.0;
    double multiplier = (center_freq - offset) / 500.0;
    return (int)((symbolLen() / 16) * multiplier) + 1;
  }

  float toneFreq(int tone) const {
    return (firstCarrier() + 2 * tone) * BASE_RATE / symbolLen();
  }

  float symbolRate() const { return BASE_RATE / symbolSepar(); }

  float charRate() const {
    return symbolRate() * bitsPerSymbol() / symbolsPerBlock();
  }

  bool isValid() const {
    if (tones < 2 || tones > 256 || (tones & (tones - 1)) != 0) {
      LOGE("Olivia: tones must be a power of 2 (2 - 256)");
      return false;
    }
    if (!(bandwidth == 125 || bandwidth == 250 || bandwidth == 500 ||
          bandwidth == 1000 || bandwidth == 2000)) {
      LOGE("Olivia: bandwidth must be 125, 250, 500, 1000 or 2000");
      return false;
    }
    if (symbolLen() < 16 || symbolLen() > MAX_SYMBOL_LEN) {
      LOGE("Olivia: %d tones with %d Hz are not supported", tones, bandwidth);
      return false;
    }
    if (sync_margin < 1 || sync_integration < 1 || sync_threshold <= 0) {
      LOGE("Olivia: invalid synchronizer settings");
      return false;
    }
    if (firstCarrier() < 1 || toneFreq(tones) >= 0.45f * BASE_RATE) {
      LOGE("Olivia: the center frequency %.1f Hz is out of range",
           (double)center_freq);
      return false;
    }
    if (sample_rate < 4000) {
      LOGE("Olivia: the sample rate must be at least 4000 Hz");
      return false;
    }
    return true;
  }

  static constexpr int MAX_SYMBOL_LEN = 2048;
 
 protected:
  static bool parseMode(const char* mode, int& tones, int& bandwidth,
                        bool& contestia) {
    if (mode == nullptr) return false;
    const char* rest;
    if (startsWith(mode, "olivia")) {
      contestia = false;
      rest = mode + 6;
      tones = 32;
      bandwidth = 1000;
    } else if (startsWith(mode, "contestia")) {
      contestia = true;
      rest = mode + 9;
      tones = 8;
      bandwidth = 250;
    } else {
      return false;
    }
    if (*rest == 0) return true;
    if (*rest != '-' && *rest != '_') return false;
    char* end;
    tones = strtol(rest + 1, &end, 10);
    if (*end != '-' && *end != '_' && *end != '/') return false;
    bandwidth = strtol(end + 1, &end, 10);
    if (tolower(*end) == 'k') {
      bandwidth *= 1000;
      end++;
    }
    if (*end != 0) return false;
    if (tones < 2 || tones > 256 || (tones & (tones - 1)) != 0) return false;
    return bandwidth == 125 || bandwidth == 250 || bandwidth == 500 ||
           bandwidth == 1000 || bandwidth == 2000;
  }
 
  static bool startsWith(const char* str, const char* prefix) {
    while (*prefix) {
      if (tolower(*str++) != *prefix++) return false;
    }
    return true;
  }
};

class OliviaCodec {
 public:
  void begin(int bits_per_symbol, bool is_contestia) {
    bits = bits_per_symbol;
    contestia = is_contestia;
    block_len = contestia ? 32 : 64;
  }

  bool isSkipped(uint8_t ch) const { return contestia && ch == '\r'; }

  void encodeBlock(const uint8_t* chars, uint8_t* symbols) {
    int8_t fht[64];
    for (int t = 0; t < block_len; t++) symbols[t] = 0;
    for (int b = 0; b < bits; b++) {
      for (int t = 0; t < block_len; t++) fht[t] = 0;
      uint8_t ch = encodeChar(chars[b]);
      if (ch < block_len)
        fht[ch] = 1;
      else
        fht[ch - block_len] = -1;
      ifht(fht, block_len);
      int code_bit = (b * shift()) & (block_len - 1);
      int rotate = 0;
      for (int t = 0; t < block_len; t++) {
        if ((scramblingCode() >> code_bit) & 1) fht[t] = -fht[t];
        code_bit = (code_bit + 1) & (block_len - 1);
        if (fht[t] < 0) {
          int bit = b + rotate;
          if (bit >= bits) bit -= bits;
          symbols[t] |= 1 << bit;
        }
        if (++rotate >= bits) rotate = 0;
      }
    }
  }

  uint8_t decodeChar(const int8_t* soft, int b, float& peak, float& noise) {
    int32_t fht[64];
    int code_bit = (b * shift()) & (block_len - 1);
    int rotate = b;
    for (int t = 0; t < block_len; t++) {
      int32_t bit = soft[t * bits + rotate];
      if ((scramblingCode() >> code_bit) & 1) bit = -bit;
      fht[t] = bit;
      code_bit = (code_bit + 1) & (block_len - 1);
      if (++rotate >= bits) rotate = 0;
    }
    fhtTransform(fht, block_len);
    int32_t max = 0;
    int pos = 0;
    float sum = 0;
    for (int t = 0; t < block_len; t++) {
      float v = fht[t];
      sum += v * v;
      if (abs(fht[t]) > abs(max)) {
        max = fht[t];
        pos = t;
      }
    }
    uint8_t ch = pos;
    if (max < 0) ch += block_len;
    peak = abs(max);
    noise = (sum - peak * peak) / (block_len - 1);
    return decodeChar(ch);
  }
 
  int blockLen() const { return block_len; }
 
  static uint8_t grayCode(uint8_t binary) { return binary ^ (binary >> 1); }
 
  static uint8_t binaryCode(uint8_t gray) {
    gray ^= gray >> 4;
    gray ^= gray >> 2;
    gray ^= gray >> 1;
    return gray;
  }
 
 protected:
  int bits = 5;
  int block_len = 64;
  bool contestia = false;
 
  uint64_t scramblingCode() const {
    return contestia ? 0xEDB88320ull : 0xE257E6D0291574ECull;
  }
 
  int shift() const { return contestia ? 5 : 13; }
 
  uint8_t encodeChar(uint8_t ch) const {
    if (!contestia) return ch & 0x7F;
    if (ch >= 'a' && ch <= 'z') ch += 'A' - 'a';
    if (ch == ' ') return 59;
    if (ch == '\n') return 60;  // fldigi shows '\r' as new line
    if (ch == 0) return 0;
    if (ch >= 33 && ch <= 90) return ch - 32;
    if (ch == 8) return 61;
    return '?' - 32;
  }
 
  uint8_t decodeChar(uint8_t ch) const {
    if (!contestia || ch == 0) return ch;
    if (ch == 59) return ' ';
    if (ch == 60) return '\n';
    if (ch == 61) return 8;
    return ch + 32;
  }

  template <class T>
  static void fhtTransform(T* data, int len) {
    for (int step = 1; step < len; step *= 2)
      for (int ptr = 0; ptr < len; ptr += 2 * step)
        for (int j = ptr; j < ptr + step; j++) {
          T a = data[j], b = data[j + step];
          data[j] = b + a;
          data[j + step] = b - a;
        }
  }

  template <class T>
  static void ifht(T* data, int len) {
    for (int step = len / 2; step; step /= 2)
      for (int ptr = 0; ptr < len; ptr += 2 * step)
        for (int j = ptr; j < ptr + step; j++) {
          T a = data[j], b = data[j + step];
          data[j] = a - b;
          data[j + step] = a + b;
        }
  }
};
 
}  // namespace tinymodem