MidiDeviceMap.hpp

#pragma once
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace Protocols::MIDIDevices
{
 
enum class MessageType
{
  CC,
  CC14,
  NRPN,
  RPN,
  Note,
  PitchBend,
  Aftertouch,
  PolyAftertouch,
  Program
};
 
enum class Kind
{
  Fader,
  Knob,
  Encoder,
  Button,
  Pad,
  Key,
  Wheel,
  Ribbon,
  XY,
  Parameter,
  Other
};
 
enum class Direction
{
  In,
  Out,
  Both
};
 
enum class ValueMode
{
  Absolute,
  Relative
};
 
enum class Encoding
{
  TwosComplement,
  SignedBit,
  SignedBit2,
  BinaryOffset
};
 
struct Bank
{
  int msb{-1};
  int lsb{-1};
 
  bool empty() const noexcept { return msb < 0 && lsb < 0; }
  bool operator==(const Bank&) const noexcept = default;
};
 
struct Message
{
  MessageType type{MessageType::CC};
 
  std::vector<int> channels;
 
  int number{-1};
 
  int lsb{-1};
 
  Bank bank;
 
  int rangeFrom{-1};
  int rangeTo{-1};
 
  bool hasRange() const noexcept { return rangeFrom >= 0 && rangeTo >= rangeFrom; }
};
 
struct Label
{
  int from{};
  int to{};
  std::string name;
};
 
struct Scale
{
  std::optional<double> min;
  std::optional<double> max;
 
  std::string from;
  std::string to;
 
  std::string unit;
 
  bool empty() const noexcept
  {
    return !min && !max && from.empty() && to.empty();
  }
};
 
struct Value
{
  ValueMode mode{ValueMode::Absolute};
 
  std::optional<Encoding> encoding;
 
  std::optional<int> min;
  std::optional<int> max;
  std::optional<int> def;
 
  std::vector<int> sends;
 
  bool bipolar{};
 
  Scale scale;
 
  std::vector<Label> labels;
 
  std::optional<bool> momentary;
 
  bool inverted{};
 
  bool pickup{};
};
 
struct Layer
{
  std::string name;
 
  std::string of;
 
  bool empty() const noexcept { return name.empty(); }
};
 
struct Condition
{
  int program{};
  Bank bank;
};
 
struct Control
{
  std::string name;
  Kind kind{Kind::Other};
 
  std::vector<std::string> group;
 
  Direction direction{Direction::In};
 
  Message message;
 
  std::optional<Message> feedback;
 
  Value value;
 
  std::vector<Condition> when;
 
  Layer layer;
 
  std::string description;
};
 
struct Preset
{
  std::string name;
 
  std::vector<std::string> sysex;
 
  bool empty() const noexcept { return name.empty() && sysex.empty(); }
};
 
struct Source
{
  std::string format;
 
  std::string license;
 
  std::string redistribution;
 
  std::vector<std::string> notices;
 
  std::vector<std::string> authors;
 
  std::string project;
  std::string url;
 
  std::string path;
};
 
struct DeviceMap
{
  std::string manufacturer;
  std::string model;
  std::string description;
 
  std::string requirement;
 
  Preset preset;
 
  std::vector<std::string> match;
 
  Source source;
 
  std::vector<Control> controls;
 
  std::vector<std::string> warnings;
 
  std::string label() const;
 
  bool empty() const noexcept { return controls.empty(); }
};
 
bool isNoteName(const Control& c) noexcept;
 
bool namesSomething(std::string_view s) noexcept;
 
std::string deviceNodeName(const DeviceMap& map);
 
std::pair<int, int> naturalRange(MessageType t) noexcept;
 
std::pair<int, int> resolvedRange(const Value& v, MessageType t) noexcept;
 
int decodeRelative(int byte, Encoding e) noexcept;
 
int encodeRelative(int delta, Encoding e) noexcept;
 
struct DeviceHeader
{
  std::string manufacturer;
  std::string model;
  std::string description;
  std::string requirement;
  Preset preset;
  std::vector<std::string> match;
 
  std::string label() const;
};
 
std::optional<DeviceHeader> parseDeviceMapHeader(std::string_view text);
 
std::optional<DeviceMap> parseDeviceMap(std::string_view text);
 
std::string_view toString(Kind) noexcept;
std::string_view toString(MessageType) noexcept;
 
}