GGWave.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 "ReedSolomon.h"
 
namespace tinymodem {

enum GGWaveProtocolId {
  GGWAVE_AUDIBLE_NORMAL = 0,
  GGWAVE_AUDIBLE_FAST = 1,
  GGWAVE_AUDIBLE_FASTEST = 2,
  GGWAVE_ULTRASOUND_NORMAL = 3,
  GGWAVE_ULTRASOUND_FAST = 4,
  GGWAVE_ULTRASOUND_FASTEST = 5,
  GGWAVE_DT_NORMAL = 6,
  GGWAVE_DT_FAST = 7,
  GGWAVE_DT_FASTEST = 8,
};

struct GGWaveProtocol {
  GGWaveProtocolId id;
  const char* mode;
  int freq_start;
  int frames_per_tx;
  int bytes_per_tx;

  int tones() const { return 2 * bytes_per_tx; }
};

using GGWaveRS = RSCodec;

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

  static constexpr int BASE_FRAME = 1024;
  static constexpr int BASE_RATE = 48000;
  static constexpr int MAX_PAYLOAD = 140;
  static constexpr int MARKER_FRAMES = 16;
  static constexpr int MARKER_TONES = 16;
  static constexpr int LENGTH_BYTES = 3;

  GGWaveProtocolId protocol = GGWAVE_AUDIBLE_FAST;
  float volume = 1.0f;
  bool dss = false;
  bool rx_any_speed = true;
  float marker_threshold = 3.0f;
  bool rx_one = false;
  uint8_t channel = 0;
  float rx_noise = 0.0f;

  bool setMode(const char* mode) {
    const GGWaveProtocol* p = findMode(mode);
    if (p == nullptr) return false;
    protocol = p->id;
    return true;
  }

  static bool isMode(const char* mode) { return findMode(mode) != nullptr; }

  const GGWaveProtocol& protocolInfo() const {
    const GGWaveProtocol* p = findProtocol(protocol);
    return p != nullptr ? *p : protocols()[1];
  }

  static int protocolCount() { return 9; }

  static const GGWaveProtocol* protocols() {
    static const GGWaveProtocol table[] = {
        {GGWAVE_AUDIBLE_NORMAL, "ggwave-normal", 40, 9, 3},
        {GGWAVE_AUDIBLE_FAST, "ggwave-fast", 40, 6, 3},
        {GGWAVE_AUDIBLE_FASTEST, "ggwave-fastest", 40, 3, 3},
        {GGWAVE_ULTRASOUND_NORMAL, "ggwave-u-normal", 320, 9, 3},
        {GGWAVE_ULTRASOUND_FAST, "ggwave-u-fast", 320, 6, 3},
        {GGWAVE_ULTRASOUND_FASTEST, "ggwave-u-fastest", 320, 3, 3},
        {GGWAVE_DT_NORMAL, "ggwave-dt-normal", 24, 9, 1},
        {GGWAVE_DT_FAST, "ggwave-dt-fast", 24, 6, 1},
        {GGWAVE_DT_FASTEST, "ggwave-dt-fastest", 24, 3, 1},
    };
    return table;
  }

  static const GGWaveProtocol* findProtocol(int id) {
    if (id < 0 || id >= protocolCount()) return nullptr;
    return &protocols()[id];
  }

  int frameSize() const {
    return (int)((int64_t)sample_rate * BASE_FRAME / BASE_RATE);
  }

  float binFrequency(int bin) const {
    return (float)bin * sample_rate / frameSize();
  }

  static int eccBytes(int len) {
    return len < 4 ? 2 : (2 * (len / 5) > 4 ? 2 * (len / 5) : 4);
  }

  static int encodedBytes(int len) { return LENGTH_BYTES + len + eccBytes(len); }

  int dataSymbols(int len) const {
    int bpt = protocolInfo().bytes_per_tx;
    return (encodedBytes(len) + bpt - 1) / bpt;
  }

  size_t messageSamples(int len) const {
    int frames = 2 * MARKER_FRAMES +
                 dataSymbols(len) * protocolInfo().frames_per_tx;
    return (size_t)frames * frameSize();
  }

  float symbolRate() const {
    return (float)sample_rate / (frameSize() * protocolInfo().frames_per_tx);
  }

  float bitRate() const { return symbolRate() * 8 * protocolInfo().bytes_per_tx; }

  bool isValid() const {
    if (findProtocol(protocol) == nullptr) {
      LOGE("ggwave: invalid protocol: %d", protocol);
      return false;
    }
    int n = frameSize();
    if ((int64_t)n * BASE_RATE != (int64_t)sample_rate * BASE_FRAME ||
        n % 4 != 0) {
      LOGE("ggwave: the sample rate %d is not supported (e.g. use 48000)",
           (int)sample_rate);
      return false;
    }
    const GGWaveProtocol& p = protocolInfo();
    int top = p.freq_start + 16 * p.tones();
    if (2 * top >= n) {
      LOGE("ggwave: the sample rate %d is too low for %s", (int)sample_rate,
           p.mode);
      return false;
    }
    if (marker_threshold < 1.0f) {
      LOGE("ggwave: marker_threshold must be >= 1");
      return false;
    }
    return true;
  }

  static uint8_t dssMagic(int i) {
    static const uint8_t magic[64] = {
        0x96, 0x9f, 0xb4, 0xaf, 0x1b, 0x91, 0xde, 0xc5, 0x45, 0x75, 0xe8,
        0x2e, 0x0f, 0x32, 0x4a, 0x5f, 0xb4, 0x56, 0x95, 0xcb, 0x7f, 0x6a,
        0x54, 0x6a, 0x48, 0xf2, 0x0b, 0x7b, 0xcd, 0xfb, 0x93, 0x6d, 0x3c,
        0x77, 0x5e, 0xc3, 0x33, 0x47, 0xc0, 0xf1, 0x71, 0x32, 0x33, 0x27,
        0x35, 0x68, 0x47, 0x1f, 0x4e, 0xac, 0x23, 0x42, 0x5f, 0x00, 0x37,
        0xa4, 0x50, 0x6d, 0x48, 0x24, 0x91, 0x7c, 0xa1, 0x4e,
    };
    return magic[i % 64];
  }
 
 protected:
  static const GGWaveProtocol* findMode(const char* mode) {
    if (mode == nullptr) return nullptr;
    if (equals(mode, "ggwave")) return &protocols()[1];
    for (int j = 0; j < protocolCount(); j++)
      if (equals(mode, protocols()[j].mode)) return &protocols()[j];
    return nullptr;
  }
 
  static bool equals(const char* a, const char* b) {
    while (*a && *b) {
      if (tolower(*a) != tolower(*b)) return false;
      a++;
      b++;
    }
    return *a == *b;
  }
};
 
}  // namespace tinymodem