OSCData.h

#pragma once
#include <stdint.h>
#include <string.h>
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
 
namespace audio_tools {
 
struct OSCBinaryData {
  uint8_t *data = nullptr;
  size_t len = 0;
  OSCBinaryData(uint8_t *data, int len) {
    this->data = data;
    this->len = len;
  }
  OSCBinaryData() = default;
};
struct OSCBinaryData {…};
 
enum class OSCCompare { Matches, Equals, StartsWith, EndsWith, Contains };
 
class OSCData {
 public:
  OSCData() = default;
  OSCData(uint8_t *data, uint32_t maxlen) {
    binary_content.data = data;
    binary_content.len = maxlen;
  }
  OSCData(uint8_t *data, uint32_t maxlen) {…}
 
  void setAddress(const char *address) {
    int adr_len = OSCData::oscSize(address);
    memset(binary_content.data, 0, adr_len);
    strcpy((char *)binary_content.data, address);
    write_pos = adr_len;
  }
  void setAddress(const char *address) {…}
 
  void setFormat(const char *format) {
    int fmt_len = OSCData::oscFormatSize(strlen(format));
    memset(binary_content.data + write_pos, 0, fmt_len);
    binary_content.data[write_pos] = ',';
    read_format_start = binary_content.data + write_pos + 1;
    strcpy((char *)read_format_start, format);
    write_pos += fmt_len;
    read_data = binary_content.data + write_pos;
  }
  void setFormat(const char *format) {…}
 
  bool write(int32_t number) {
    int32_t number_net = htonl(number);
    if (write_pos + sizeof(int32_t) > binary_content.len) {
      return false;
    }
    memcpy(binary_content.data + write_pos, &number_net, sizeof(int32_t));
    write_pos += sizeof(int32_t);
    return true;
  }
  bool write(int32_t number) {…}
 
  bool write(int64_t number) {
    if (write_pos + sizeof(int64_t) > binary_content.len) {
      return false;
    }
    int64_t number_net = htonll(number);
    memcpy(binary_content.data + write_pos, &number_net, sizeof(int64_t));
    write_pos += sizeof(int64_t);
    return true;
  }
  bool write(int64_t number) {…}
 
#ifndef IS_DESKTOP
 
  bool write(unsigned long number) { return write((uint64_t)number); }
 
#endif
 
  bool write(uint64_t number) {
    if (write_pos + sizeof(uint64_t) > binary_content.len) {
      return false;
    }
    uint64_t number_net = htonll(number);
    memcpy(binary_content.data + write_pos, &number_net, sizeof(uint64_t));
    write_pos += sizeof(uint64_t);
    return true;
  }
  bool write(uint64_t number) {…}
 
  bool write(double fp64) { return write(*(int64_t *)&fp64); }
 
  bool write(const char *str) {
    int str_len = OSCData::oscSize(str);
    if (write_pos + str_len > binary_content.len) {
      return false;
    }
    memset(binary_content.data + write_pos, 0, str_len);
    strcpy((char *)binary_content.data + write_pos, str);
    write_pos += str_len;
    return true;
  }
  bool write(const char *str) {…}
 
  bool write(OSCBinaryData &data) { return write(data.data, data.len); }
 
  bool write(const uint8_t *dataArg, int len) {
    uint32_t size = OSCData::oscSize(len) + sizeof(int32_t);
    if (write_pos + size > binary_content.len) {
      return false;
    }
    memset(binary_content.data + write_pos, 0, size);
    int32_t len_net = htonl(len);
    memcpy((binary_content.data + write_pos), &len_net, sizeof(int32_t));
    memcpy((binary_content.data + write_pos + sizeof(int32_t)), dataArg, len);
    write_pos += size;
    return true;
  }
  bool write(const uint8_t *dataArg, int len) {…}
 
  void clear() {
    write_pos = 0;
    read_format_start = nullptr;
    read_data = nullptr;
    binary_content.data = nullptr;
    binary_content.len = 0;
    callbacks.clear();
  }
  void clear() {…}
 
  uint8_t *data() { return binary_content.data; }
 
  int size() { return write_pos; }
 
  bool parse(uint8_t *data, size_t len) {
    // store data
    binary_content.data = data;
    binary_content.len = len;
 
    // to support size()
    write_pos = len;
 
    // Print frist 20 digits
    if (is_log_active) logMsg(data, 20);
 
    if (data[0] != '/') return false;
 
    // determine address length 4 byte aligned
    int addr_len = OSCData::oscSize((char *)binary_content.data);
 
    // determine start of format
    read_format_start = (uint8_t *)getAddress() + addr_len;
 
    // check start of format
    if (*read_format_start != ',') {
      return false;
    }
 
    int format_len =
        OSCData::oscFormatSize(strlen((char *)read_format_start + 1));
 
    // determine start of data
    read_data = read_format_start + format_len;
 
    // move past ,
    read_format_start++;
 
    if (callbacks.size() > 0) {
      for (auto &cb : callbacks) {
        if (compare(cb.compare, cb.address, getAddress())) {
          if (cb.callback != nullptr) {
            if (cb.callback(*this, reference)) {
              return true;
            }
          }
        }
      }
      // return false if no callback was called successfully
      return false;
    }
 
    return true;
  }
  bool parse(uint8_t *data, size_t len) {…}
 
  void logMsg(uint8_t *data, int len) {
    Serial.print("OSCData: ");
    for (int i = 0; i < len; i++) {
      Serial.print((char)data[i]);
    }
#ifndef IS_DESKTOP
    Serial.println();
    Serial.print("Hex Data: ");
    for (int i = 0; i < len; i++) {
      Serial.print(data[i], HEX);
    }
    Serial.println();
#endif
  }
 
  const char *getAddress() { return (const char *)binary_content.data; }
 
  const char *getFormat() { return (const char *)read_format_start; }
 
  float readFloat() {
    int64_t number = readInt32();
    return *((float *)&number);
  }
  float readFloat() {…}
 
  int32_t readInt32() {
    int32_t number;
    memcpy(&number, read_data, sizeof(int32_t));
    read_data += sizeof(int32_t);
    return ntohl(number);
  }
  int32_t readInt32() {…}
 
  int64_t readInt64() {
    int64_t number;
    memcpy(&number, read_data, sizeof(int64_t));
    read_data += sizeof(int64_t);
    return ntohll(number);
  }
  int64_t readInt64() {…}
 
  uint64_t readTime() { return (uint64_t)readInt64(); }
 
  double readDouble() {
    int64_t number = readInt64();
    return *((double *)&number);
  }
  double readDouble() {…}
 
  const char *readString() {
    const char *str = (const char *)read_data;
    int str_len = OSCData::oscSize(str);
    read_data += str_len;
    return str;
  }
  const char *readString() {…}
 
  const OSCBinaryData readData() {
    OSCBinaryData result;
    int32_t len = 0;
    memcpy(&len, read_data, sizeof(int32_t));
    result.len = ntohl(len);
    result.data = read_data + sizeof(int32_t);
    read_data += (OSCData::oscSize(result.len) + sizeof(int32_t));
    return result;
  }
  const OSCBinaryData readData() {…}
 
  void setLogActive(bool active) { is_log_active = active; }
 
  OSCBinaryData &messageData() { return binary_content; }
 
  static int oscSize(int len) {
    if (len % 4 == 0) return len;
    int padding = 4 - (len % 4);
    return len + padding;
  }
  static int oscSize(int len) {…}
 
  static int oscSize(OSCBinaryData data) {
    return sizeof(uint32_t) + OSCData::oscSize(data.len);
  }
  static int oscSize(OSCBinaryData data) {…}
 
  static int oscSize(const char *str) {
    // +1 for trailing 0
    return OSCData::oscSize(strlen(str) + 1);
  }
  static int oscSize(const char *str) {…}
 
  static int oscFormatSize(int len) {
    //+2 for , and trailing 0
    return oscSize(len + 2);
  }
  static int oscFormatSize(int len) {…}
 
  static int oscFormatSize(const char *str) {
    return oscFormatSize(strlen(str));
  }
  static int oscFormatSize(const char *str) {…}
 
  void setReference(void *ref) { reference = ref; }
 
  bool addCallback(const char *address,
                   bool (*callback)(OSCData &data, void *ref),
                   OSCCompare compare = OSCCompare::Matches) {
    if (address == nullptr || callback == nullptr) return false;
 
    for (auto &cb : callbacks) {
      if (cb.address != nullptr && strcmp(cb.address, address) == 0) {
        cb.callback = callback;
        cb.compare = compare;
        return true;
      }
    }
    // add new entry
    Callback cb;
    cb.address = address;
    cb.callback = callback;
    callbacks.push_back(cb);
    return true;
  }
  bool addCallback(const char *address, {…}
 
 protected:
  int write_pos = 0;
  uint8_t *read_format_start = nullptr;
  uint8_t *read_data = nullptr;
  bool is_log_active = false;
  OSCBinaryData binary_content;
  void *reference = nullptr;
 
  struct Callback {
    const char *address = nullptr;
    bool (*callback)(OSCData &data, void *ref) = nullptr;
    OSCCompare compare;
  };
  struct Callback {…};
  Vector<Callback> callbacks;
 
  bool compare(OSCCompare compare, const char *strRef, const char *strCompare) {
    switch (compare) {
      case OSCCompare::Matches:
        return StrView(strRef).matches(strCompare);
      case OSCCompare::Equals:
        return StrView(strRef).equals(strCompare);
      case OSCCompare::StartsWith:
        return StrView(strRef).startsWith(strCompare);
      case OSCCompare::EndsWith:
        return StrView(strRef).endsWith(strCompare);
      case OSCCompare::Contains:
        return StrView(strRef).contains(strCompare);
    }
    return false;
  }
 
  uint8_t *getEnd() { return binary_content.data + binary_content.len; }
};
class OSCData {…};
 
}  // namespace audio_tools