ump_buffer.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/ump.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <vector>
 
namespace pulp::midi {

struct UmpEvent {
    UmpPacket packet;
    int32_t sample_offset = 0;
};

class UmpBuffer {
  public:
    UmpBuffer() {
        reserve(kInitialCapacity);
    }
    UmpBuffer(const UmpBuffer& other)
        : events_(other.events_), limit_to_reserved_capacity_(other.limit_to_reserved_capacity_),
          dropped_events_(other.dropped_events_) {
        reserve(other.capacity());
    }
    UmpBuffer& operator=(const UmpBuffer& other) {
        if (this != &other) {
            events_ = other.events_;
            limit_to_reserved_capacity_ = other.limit_to_reserved_capacity_;
            dropped_events_ = other.dropped_events_;
            reserve(other.capacity());
        }
        return *this;
    }
    UmpBuffer(UmpBuffer&&) noexcept = default;
    UmpBuffer& operator=(UmpBuffer&&) noexcept = default;
 
    bool add(const UmpEvent& e) {
        if (!can_append()) {
            record_drop();
            return false;
        }
        events_.push_back(e);
        prepare_sort_after_growth();
        return true;
    }
    bool add(UmpEvent&& e) {
        if (!can_append()) {
            record_drop();
            return false;
        }
        events_.push_back(std::move(e));
        prepare_sort_after_growth();
        return true;
    }
    bool add(const UmpPacket& p, int32_t sample_offset = 0) {
        if (!can_append()) {
            record_drop();
            return false;
        }
        events_.push_back({p, sample_offset});
        prepare_sort_after_growth();
        return true;
    }
 
    void clear() {
        events_.clear();
        dropped_events_ = 0;
    }
    bool empty() const { return events_.empty(); }
    std::size_t size() const { return events_.size(); }
    std::size_t capacity() const { return events_.capacity(); }
    std::uint32_t dropped_event_count() const { return dropped_events_; }
    void reserve(std::size_t capacity) {
        events_.reserve(capacity);
        sort_indices_.reserve(events_.capacity());
        sort_events_.reserve(events_.capacity());
    }
    void set_realtime_capacity_limit(bool enabled = true) {
        limit_to_reserved_capacity_ = enabled;
    }
    bool realtime_capacity_limited() const { return limit_to_reserved_capacity_; }

    void sort() {
        const auto count = events_.size();
        if (count < 2)
            return;
        sort_indices_.resize(count);
        for (std::size_t i = 0; i < count; ++i)
            sort_indices_[i] = i;
        std::sort(sort_indices_.begin(), sort_indices_.end(), [this](std::size_t a, std::size_t b) {
            if (events_[a].sample_offset != events_[b].sample_offset)
                return events_[a].sample_offset < events_[b].sample_offset;
            return a < b;
        });
        sort_events_.resize(count);
        for (std::size_t i = 0; i < count; ++i)
            sort_events_[i] = events_[sort_indices_[i]];
        events_.swap(sort_events_);
    }
 
    auto begin()       { return events_.begin(); }
    auto end()         { return events_.end(); }
    auto begin() const { return events_.begin(); }
    auto end() const   { return events_.end(); }
 
    const UmpEvent& operator[](std::size_t i) const { return events_[i]; }
 
  private:
    void prepare_sort_after_growth() {
        if (!limit_to_reserved_capacity_) {
            sort_indices_.reserve(events_.capacity());
            sort_events_.reserve(events_.capacity());
        }
    }
    bool can_append() const {
        return !limit_to_reserved_capacity_ || events_.size() < events_.capacity();
    }
    void record_drop() {
        if (dropped_events_ < std::numeric_limits<std::uint32_t>::max()) {
            ++dropped_events_;
        }
    }
 
    static constexpr std::size_t kInitialCapacity = 128;
    std::vector<UmpEvent> events_;
    std::vector<std::size_t> sort_indices_;
    std::vector<UmpEvent> sort_events_;
    bool limit_to_reserved_capacity_ = false;
    std::uint32_t dropped_events_ = 0;
};
 
} // namespace pulp::midi