midi.cpp

Go to the documentation of this file.

#include "midi.hpp"
 
#include "input_validation.hpp"
 
#include <rtmidi/RtMidi.h>
 
#include <algorithm>
#include <cmath>
#include <deque>
#include <fstream>
#include <iostream>
#include <mutex>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include<charconv>
 
namespace acmxvk::midi {
 
    void parse_block(std::string_view b) {
        int stat = 0, value = 0, code = 0;
        const char *cur = b.data();
        const char *end = b.data() + b.size();
        auto [ptr_value, e] = std::from_chars(cur, end, stat);
        if(e  != std::errc{}) {
            std::cerr << "failed to parse status bytesn\n";
            return;
        }
        cur = ptr_value;
        while(cur != end && *cur == ' ') {
            cur ++;
        }
 
        auto [ptr_value2, e2] = std::from_chars(cur, end, code);
        if(e2 != std::errc{}) {
            std::cerr << "Failed to parse code\n";
            return;
        }
        cur = ptr_value2;
        while(cur != end && *cur == ' ') {
            cur++;
        }
        auto [ptr3, e3] = std::from_chars(cur, end, value);
        if(e3 != std::errc{}) {
            std::cerr << "Error failed to pasre  value\n";
            return;
        }
 
        std::cout <<  "Status: " << stat << " CC: " << code << " Value: " << value << "\n";
    }
 
    std::vector<MidiMapping> load_mapping_file(const std::string &filename) {
        input::validate_string(filename, input::StringKind::Path,
                               "MIDI map path");
        input::validate_file_size(filename, "MIDI map file");
        std::ifstream mapping_input(filename);
        if (!mapping_input) {
            throw std::runtime_error("could not open MIDI map file: " + filename);
        }
 
        std::vector<MidiMapping> mappings;
        std::string line;
        std::size_t line_number = 0;
        while (input::read_bounded_line(mapping_input, line, "MIDI map file",
                                        line_number + 1)) {
 
        parse_block(line);
            ++line_number;
            const std::size_t first = line.find_first_not_of(" \t\r");
            if (first == std::string::npos || line[first] == '#') {
                continue;
            }
            if (mappings.size() >= input::MAX_MIDI_MAPPINGS) {
                throw std::runtime_error(
                    "MIDI map file contains too many mappings");
            }
            input::validate_string(line, input::StringKind::StructuredValue,
                                   "MIDI map entry");
 
            std::istringstream stream(line);
            std::string action_pair;
            char open_brace = 0;
            char close_brace = 0;
            int status = 0;
            int data1 = 0;
            int data2 = 0;
            if (!(stream >> action_pair >> open_brace >> status >> data1 >> data2 >>
                  close_brace) ||
                open_brace != '{' || close_brace != '}') {
                throw std::runtime_error(
                    "invalid MIDI map entry at " + filename + ':' +
                    std::to_string(line_number));
            }
            stream >> std::ws;
            if (!stream.eof()) {
                throw std::runtime_error(
                    "unexpected text in MIDI map at " + filename + ':' +
                    std::to_string(line_number));
            }
 
            const std::size_t colon = action_pair.find(':');
            if (colon == std::string::npos || colon == 0 ||
                colon + 1 >= action_pair.size() ||
                action_pair.find(':', colon + 1) != std::string::npos) {
                throw std::runtime_error(
                    "invalid MIDI action pair at " + filename + ':' +
                    std::to_string(line_number));
            }
 
            std::size_t primary_parsed = 0;
            std::size_t secondary_parsed = 0;
            int primary = 0;
            int secondary = 0;
            try {
                primary = std::stoi(action_pair.substr(0, colon),
                                    &primary_parsed);
                secondary = std::stoi(action_pair.substr(colon + 1),
                                      &secondary_parsed);
            } catch (const std::exception &) {
                throw std::runtime_error(
                    "invalid MIDI action code at " + filename + ':' +
                    std::to_string(line_number));
            }
            if (primary_parsed != colon ||
                secondary_parsed != action_pair.size() - colon - 1 ||
                primary <= 0 || primary > 65535 || secondary < 0 ||
                secondary > 65535 || status < 0 || status > 255 ||
                data1 < 0 || data1 > 255 || data2 < 0 || data2 > 255) {
                throw std::runtime_error(
                    "MIDI map value outside its valid range at " + filename +
                    ':' + std::to_string(line_number));
            }
 
            mappings.push_back(
                {primary, secondary, static_cast<unsigned char>(status),
                 static_cast<unsigned char>(data1),
                 static_cast<unsigned char>(data2)});
        }
        return mappings;
    }
 
    class MidiInput::Impl {
      public:
        static constexpr std::size_t MAX_PENDING_MESSAGES = 256;
        static constexpr std::size_t MAX_MESSAGE_BYTES = 1024;
 
        ~Impl() { close(); }
 
        bool open(int requested_port) {
            close();
            if (requested_port < 0) {
                std::cerr << "acmxvk: MIDI port must be non-negative\n";
                return false;
            }
 
            try {
                input = std::make_unique<RtMidiIn>();
                const unsigned int port_count = input->getPortCount();
                const auto port = static_cast<unsigned int>(requested_port);
                if (port_count == 0) {
                    std::cerr << "acmxvk: no MIDI input ports found\n";
                    input.reset();
                    return false;
                }
                if (port >= port_count) {
                    std::cerr << "acmxvk: MIDI input port " << port
                              << " is outside the available range 0.."
                              << (port_count - 1) << '\n';
                    input.reset();
                    return false;
                }
 
                port_name = input->getPortName(port);
                acmxvk::input::validate_string(
                    port_name, acmxvk::input::StringKind::DisplayText,
                    "MIDI port name");
                input->ignoreTypes(false, false, false);
                input->setCallback(&Impl::messageCallback, this);
                input->openPort(port, "ACMXVK MIDI Input");
                open_port = requested_port;
                std::cout << "acmxvk: MIDI input " << open_port << ": "
                          << port_name << '\n';
                return input->isPortOpen();
            } catch (const RtMidiError &error) {
                std::cerr << "acmxvk: MIDI input error: " << error.getMessage()
                          << '\n';
                close();
                return false;
            }
        }
 
        void close() {
            if (input != nullptr) {
                try {
                    input->cancelCallback();
                    if (input->isPortOpen()) {
                        input->closePort();
                    }
                } catch (const RtMidiError &error) {
                    std::cerr << "acmxvk: error closing MIDI input: "
                              << error.getMessage() << '\n';
                }
                input.reset();
            }
            {
                std::lock_guard<std::mutex> lock(queue_mutex);
                pending_messages.clear();
                message_sequence = 0;
                dropped_messages = 0;
            }
            open_port = -1;
            port_name.clear();
        }
 
        [[nodiscard]] bool is_open() const {
            return input != nullptr && input->isPortOpen();
        }
 
        [[nodiscard]] std::vector<MidiMessage> pollMessages() {
            std::lock_guard<std::mutex> lock(queue_mutex);
            std::vector<MidiMessage> messages;
            messages.reserve(pending_messages.size());
            while (!pending_messages.empty()) {
                messages.push_back(std::move(pending_messages.front()));
                pending_messages.pop_front();
            }
            return messages;
        }
 
        [[nodiscard]] std::uint64_t droppedMessageCount() const {
            std::lock_guard<std::mutex> lock(queue_mutex);
            return dropped_messages;
        }
 
        static void messageCallback(double delta_seconds,
                                    std::vector<unsigned char> *bytes,
                                    void *user_data) {
            if (user_data == nullptr || bytes == nullptr || bytes->empty()) {
                return;
            }
            static_cast<Impl *>(user_data)->enqueue(delta_seconds, *bytes);
        }
 
        void enqueue(double delta_seconds,
                     const std::vector<unsigned char> &bytes) {
            std::lock_guard<std::mutex> lock(queue_mutex);
            if (bytes.size() > MAX_MESSAGE_BYTES) {
                ++dropped_messages;
                return;
            }
            if (pending_messages.size() >= MAX_PENDING_MESSAGES) {
                pending_messages.pop_front();
                ++dropped_messages;
            }
            pending_messages.push_back(
                MidiMessage{std::isfinite(delta_seconds)
                                ? std::max(delta_seconds, 0.0)
                                : 0.0,
                            bytes, ++message_sequence});
        }
 
        std::unique_ptr<RtMidiIn> input;
        mutable std::mutex queue_mutex;
        std::deque<MidiMessage> pending_messages;
        std::string port_name;
        std::uint64_t message_sequence = 0;
        std::uint64_t dropped_messages = 0;
        int open_port = -1;
    };
 
    MidiInput::MidiInput() : impl(std::make_unique<Impl>()) {}
    MidiInput::~MidiInput() = default;
 
    bool MidiInput::open(int port) {
        return impl->open(port);
    }
 
    void MidiInput::close() {
        impl->close();
    }
 
    bool MidiInput::is_open() const {
        return impl->is_open();
    }
 
    std::vector<MidiMessage> MidiInput::poll_messages() {
        return impl->pollMessages();
    }
 
    std::uint64_t MidiInput::dropped_message_count() const {
        return impl->droppedMessageCount();
    }
 
    void MidiInput::list_ports(std::ostream &output) {
        try {
            RtMidiIn input;
            const unsigned int port_count = input.getPortCount();
            output << "acmxvk: found " << port_count << " MIDI input port(s)\n";
            for (unsigned int port = 0; port < port_count; ++port) {
                const std::string name = input.getPortName(port);
                acmxvk::input::validate_string(
                    name, acmxvk::input::StringKind::DisplayText,
                    "MIDI port name");
                output << "  " << port << ": " << name << '\n';
            }
        } catch (const RtMidiError &error) {
            throw std::runtime_error(std::string("could not enumerate MIDI inputs: ") +
                                     error.getMessage());
        }
    }
 
} // namespace acmxvk::midi