MFSKEncoder.h

Go to the documentation of this file.

#pragma once
 
#include <math.h>
 
#include "AudioTools.h"
#include "MFSKConfig.h"
#include "ModemBase.h"
 
namespace tinymodem {

inline unsigned grayEncode(unsigned value) { return value ^ (value >> 1); }

inline unsigned grayDecode(unsigned gray) {
  unsigned value = gray;
  for (unsigned shift = gray >> 1; shift != 0; shift >>= 1) value ^= shift;
  return value;
}

class MFSKEncoder : public ModemEncoder {
 public:
  MFSKEncoder() = default;
  MFSKEncoder(Print& out) { setOutput(out); }

  MFSKConfig defaultConfig() {
    MFSKConfig result;
    result.setMode("mfsk16");
    return result;
  }

  void setAudioInfo(audio_tools::AudioInfo info) override {
    cfg.sample_rate = info.sample_rate;
    cfg.channels = info.channels;
    cfg.bits_per_sample = info.bits_per_sample;
    if (is_active) begin();
  }
 
  audio_tools::AudioInfo audioInfo() override { return cfg; }
 
  using audio_tools::AudioEncoder::begin;

  bool begin(MFSKConfig config) {
    cfg = config;
    return begin();
  }
 
  bool begin() override {
    is_active = false;
    if (!cfg.isValid()) return false;
    if (cfg.bits_per_sample != 16) {
      LOGE("MFSKEncoder: bits_per_sample must be 16, not %d",
           (int)cfg.bits_per_sample);
      return false;
    }
    if (cfg.channels < 1) {
      LOGE("MFSKEncoder: invalid number of channels: %d", (int)cfg.channels);
      return false;
    }
    if (!tones.begin(cfg, cfg.volume)) return false;
    bits_per_symbol = cfg.bitsPerSymbol();
    samples_per_symbol = cfg.samplesPerSymbol();
    transmitting = false;
    is_active = true;
    return true;
  }
 
  void end() override {
    endTransmission();
    is_active = false;
  }

  size_t write(const uint8_t* data, size_t len) override {
    if (!is_active) return 0;
    for (size_t j = 0; j < len; j++) {
      if (!transmitting) startTransmission();
      bit_buffer = (bit_buffer << 8) | data[j];
      bit_count += 8;
      while (bit_count >= bits_per_symbol) writeBits();
    }
    return len;
  }

  bool endTransmission(size_t silence_samples = 0) override {
    if (!is_active || !transmitting) return false;
    // pad the last symbol with 0 bits
    if (bit_count > 0) {
      bit_buffer <<= bits_per_symbol - bit_count;
      bit_count = bits_per_symbol;
      writeBits();
    }
    for (int j = 0; j < TRAILER_SYMBOLS; j++) writeSymbol(-1);
    if (silence_samples) tones.tone(0, silence_samples);
    transmitting = false;
    return true;
  }

  bool isTransmitting() override { return transmitting; }

  float symbolRate() override { return cfg.symbol_rate; }

  MFSKConfig& config() { return cfg; }
 
  operator bool() override { return is_active; }
 
 protected:
  static constexpr int TRAILER_SYMBOLS = 2;
  MFSKConfig cfg;
  bool is_active = false;
  bool transmitting = false;
  int bits_per_symbol = 4;
  double samples_per_symbol = 0;
  uint32_t symbol_index = 0;
  uint32_t bit_buffer = 0;
  int bit_count = 0;
 
  void startTransmission() {
    transmitting = true;
    symbol_index = 0;
    bit_buffer = 0;
    bit_count = 0;
    // preamble: alternating lowest and highest tone
    for (int j = 0; j < cfg.preamble_symbols; j++)
      writeSymbol(j % 2 == 0 ? 0 : cfg.tones - 1);
    // sync symbols
    for (int j = 0; j < cfg.syncLength(); j++) writeSymbol(cfg.syncSymbol(j));
  }

  void writeBits() {
    unsigned value = (bit_buffer >> (bit_count - bits_per_symbol)) &
                     ((1u << bits_per_symbol) - 1);
    bit_count -= bits_per_symbol;
    bit_buffer &= (1u << bit_count) - 1;
    writeSymbol(grayEncode(value));
  }

  void writeSymbol(int tone) {
    size_t start = llround((double)symbol_index * samples_per_symbol);
    size_t stop = llround((double)(symbol_index + 1) * samples_per_symbol);
    symbol_index++;
    tones.tone(tone < 0 ? 0.0f : cfg.toneFrequency(tone), stop - start);
  }
};
 
}  // namespace tinymodem