RTTTLOutput.h

Go to the documentation of this file.

#pragma once
#include <functional>
 
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/MusicalNotes.h"
 
namespace audio_tools {
 
template <class T = int16_t>
class RTTTLOutput : public AudioOutput {
 public:
  RTTTLOutput() = default;
  RTTTLOutput(SoundGenerator<T>& generator) { setGenerator(generator); }
  RTTTLOutput(SoundGenerator<T>& generator, AudioStream& out)
      : RTTTLOutput(generator) {
    setOutput(out);
  }
  RTTTLOutput(SoundGenerator<T>& generator, AudioOutput& out)
      : RTTTLOutput(generator) {
    setOutput(out);
  }
  RTTTLOutput(SoundGenerator<T>& generator, Print& out)
      : RTTTLOutput(generator) {
    setOutput(out);
  }
 
  // Expose base-class begin overloads (e.g. begin(AudioInfo)) to avoid
  // hiding them with the no-arg begin() override below.
  using AudioOutput::begin;
 
  void setOutput(Print& out) { p_print = &out; }
 
  void setGenerator(SoundGenerator<T>& generator) { p_generator = &generator; }
 
  void setOutput(AudioStream& out) {
    setOutput((Print&)out);
    addNotifyAudioChange(out);
  }
 
  void setOutput(AudioOutput& out) {
    setOutput((Print&)out);
    addNotifyAudioChange(out);
  }
 
  bool begin() override {
    LOGD("RTTTLOutput::begin");
    if (p_generator) {
      p_generator->begin(audioInfo());
    }
    is_start = true;
    return true;
  }
 
  const char* getTitle() { return m_title.c_str(); }
 
  int getDefaultOctave() const { return m_octave; }
 
  int getDefaultDuration() const { return m_duration; }
 
  int getDefaultBpm() const { return m_bpm; }
 
  size_t write(const uint8_t* data, size_t len) override {
    LOGD("write: %d", len);
    ring_buffer.resize(len);
    ring_buffer.reset();
    ring_buffer.writeArray(const_cast<uint8_t*>(data), len);
    // If we haven't started yet and we find a ':', we need to call begin()
    if (!is_start && find_byte(data, len, ':') >= 0) {
      LOGI("found ':' - resetting parser state by calling begin()");
      begin();
    }
    // start parsing of new rtttl string
    if (is_start) {
      // parse rtttl string
      parse_title();
      parse_defaults();
      is_start = false;
    }
    parse_notes();
    return len;
  }
 
  void setNoteCallback(
      std::function<void(float freqHz, int durationMs, int midiNote, void* ref)>
          cb) {
    noteCallback = cb;
  }
 
  void setReference(void* ref) { reference = ref; }
 
  void setTransposeOctaves(int8_t octaves) { m_tranpose_octaves = octaves; }
 
  void setRamp(uint8_t upPercent = 20, uint8_t downPercent = 30) {
    m_ramp_upPercent = upPercent;
    m_ramp_downPercent = downPercent;
  }
 
 protected:
  MusicalNotes m_notes;
  SoundGenerator<T>* p_generator = nullptr;
  RingBuffer<uint8_t> ring_buffer{0};
  Print* p_print = nullptr;
  int8_t m_tranpose_octaves = 0;
  bool is_start = true;
  char m_actual = 0;
  char m_prec = 0;
  Str m_title{40};
  int m_octave = 4;
  int m_duration = 4;
  int m_bpm = 120;
  float m_msec_semi = 750;
  void* reference = nullptr;
  uint8_t m_ramp_upPercent = 20;
  uint8_t m_ramp_downPercent = 30;
  std::function<void(float, int, int, void*)> noteCallback;
 
  int find_byte(const uint8_t* haystack, size_t haystack_len, uint8_t needle) {
    for (size_t i = 0; i < haystack_len; i++) {
      if (haystack[i] == needle) {
        return i;  // Return the index of the first match
      }
    }
    return -1;  // Return -1 if the byte is not found
  }
 
  void play_note(float freq, int msec, int midi = -1) {
    // invoke the optional callback first
    LOGI("play_note: freq=%.2f Hz, msec=%d, midi=%d", freq, msec, midi);
    if (noteCallback) noteCallback(freq, msec, midi, reference);
    if (p_print == nullptr || p_generator == nullptr) return;
 
    AudioInfo info = audioInfo();
    if (!info) return;
 
    p_generator->setPlayTime(msec, m_ramp_upPercent, m_ramp_downPercent);
    p_generator->setFrequency(freq);
    uint8_t buffer[1024];
    size_t len = p_generator->readBytes(buffer, 1024);
    while (len > 0) {
      p_print->write(buffer, len);
      len = p_generator->readBytes(buffer, 1024);
      delay(1);
    }
  }
 
  char next_char(bool convertToLower = true) {
    uint8_t c;
    if (!ring_buffer.read(c)) {
      c = 0;
    }
    m_prec = m_actual;
    m_actual = convertToLower ? tolower(c) : c;
    return m_actual;
  }
 
  void parse_title() {
    next_char(false);
    m_title = "";
    for (; m_actual != ':' && m_actual != '\0'; next_char(false)) {
      m_title += m_actual;
    }
    if (!m_title.isEmpty()) LOGI("title: %s", m_title.c_str());
  }
 
  int parse_num() {
    int val = 0;
    do {
      val *= 10;
      val += m_actual - '0';
    } while (isdigit(next_char()));
 
    return val;
  }
 
  void parse_defaults() {
    char id{' '};
 
    while (' ' == next_char());
    do {
      if (isdigit(m_actual)) {
        switch (id) {
          case 'o':
            m_octave = parse_num();
            LOGI("default octave: %d", m_octave);
            break;
          case 'd':
            m_duration = parse_num();
            LOGI("default duration: %d", m_duration);
            break;
          case 'b':
            m_bpm = parse_num();
            LOGI("default bpm: %d", m_bpm);
            break;
        }
        continue;
      } else if (isalpha(m_actual)) {
        id = m_actual;
      }
      next_char();
    } while (':' != m_actual);
 
    if (m_bpm != 0)
      m_msec_semi = 240000.0 / m_bpm;
    else
      m_msec_semi = 750.0;
 
    LOGI("msec per semi: %.2f", m_msec_semi);
  }
 
  float transpose(float frequency, int8_t octaves) {
    if (octaves == 0) return frequency;
    return frequency * powf(2.0f, octaves);
  }
 
  void parse_notes() {
    // Ensure we start reading after the defaults section
    if (m_actual == ':') next_char();
    // If m_actual is 0 but there is data in the buffer, advance to next char
    if (m_actual == 0 && ring_buffer.available() > 0) next_char();
 
    bool last_note_is_valid = false;
    float last_mult_duration = 1.0;
    int last_octave = 0;
    int last_duration = 0;
    MusicalNotes::MusicalNotesEnum last_noteEnum = MusicalNotes::C;
 
    while (m_actual != 0) {
      // skip separators
      while (m_actual == ' ' || m_actual == ',') {
        if (next_char() == 0) return;
      }
 
      if (m_actual == 0) break;
 
      // optional duration (number)
      int duration = m_duration;
      if (isdigit(m_actual)) {
        duration = parse_num();
        if (m_actual == 0) break;
      }
      last_duration = duration;
 
      // note letter or rest
      char name = m_actual;
      if (name == 'p' || name == 'r') {  // pause/rest
        next_char();
        float mult = 1.0;
        if (m_actual == '.') {
          mult = 1.5;
          next_char();
        }
        int msec = (int)((m_msec_semi / duration) * mult);
        play_note(0.0f, msec, -1);
        last_note_is_valid = false;
        continue;
      }
 
      // map letter to MusicalNotes enum
      MusicalNotes::MusicalNotesEnum noteEnum = MusicalNotes::C;
      switch (name) {
        case 'c':
          noteEnum = MusicalNotes::C;
          break;
        case 'd':
          noteEnum = MusicalNotes::D;
          break;
        case 'e':
          noteEnum = MusicalNotes::E;
          break;
        case 'f':
          noteEnum = MusicalNotes::F;
          break;
        case 'g':
          noteEnum = MusicalNotes::G;
          break;
        case 'a':
          noteEnum = MusicalNotes::A;
          break;
        case 'b':
        case 'h':
          noteEnum = MusicalNotes::B;
          break;
        default:
          next_char();
          last_note_is_valid = false;
          continue;
      }
      last_noteEnum = noteEnum;
 
      // advance to next char to inspect
      // accidental/octave/dot
      if (next_char() == 0) {
        last_note_is_valid = true;
        last_octave = m_octave;
        last_mult_duration = 1.0;
        break;
      }
 
      // accidental
      int semitone = (int)noteEnum;
      if (m_actual == '#') {
        semitone++;
        if (semitone > 11) {
          semitone = 0;
          m_octave += 1;
        }
        noteEnum = (MusicalNotes::MusicalNotesEnum)semitone;
        if (next_char() == 0) {
          last_note_is_valid = true;
          last_octave = m_octave;
          last_mult_duration = 1.0;
          break;
        }
      }
 
      // octave
      int octave = m_octave;
      if (m_actual >= '0' && m_actual <= '9') {
        octave = m_actual - '0';
        if (next_char() == 0) {
          last_note_is_valid = true;
          last_octave = octave;
          last_mult_duration = 1.0;
          break;
        }
      }
 
      // dotted duration
      float mult_duration = 1.0;
      if (m_actual == '.') {
        mult_duration = 1.5;
        if (next_char() == 0) {
          last_note_is_valid = true;
          last_octave = octave;
          last_mult_duration = mult_duration;
          break;
        }
      }
 
      float freq = m_notes.frequency(noteEnum, (uint8_t)octave);
      freq = transpose(freq, m_tranpose_octaves);
      int msec = (int)((m_msec_semi / duration) * mult_duration);
      int midi = m_notes.frequencyToMidiNote(freq);
      play_note(freq, msec, midi);
      last_note_is_valid = false;
    }
 
    // If a note is pending at the end, play it
    if (last_note_is_valid) {
      float freq = m_notes.frequency(last_noteEnum, (uint8_t)last_octave);
      freq = transpose(freq, m_tranpose_octaves);
      int msec = (int)((m_msec_semi / last_duration) * last_mult_duration);
      int midi = m_notes.frequencyToMidiNote(freq);
      play_note(freq, msec, midi);
    }
  }
};
 
}  // namespace audio_tools