segment_envelope.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/envelope_machine.hpp"
 
#include <array>
#include <cstdint>
#include <span>
 
namespace ts {

class SegmentEnvelope {
public:
    static constexpr int segment_count = 4;

    SegmentEnvelope(const EnvelopeMachine& machine,
                    std::span<const double> targets,
                    std::span<const double> segment_samples,
                    std::span<const bool> linear,
                    double release_target,
                    double release_samples,
                    bool release_linear,
                    double after_release,
                    std::int64_t control_tick_samples);

    [[nodiscard]] std::int64_t note_off_sample() const noexcept { return note_off_; }

    [[nodiscard]] std::int64_t release_samples() const noexcept { return release_samples_; }

    void note_off(std::int64_t sample, int damper = 0);

    [[nodiscard]] static std::int64_t
    defer_to_control_tick(std::int64_t sample, std::int64_t control_tick_samples) noexcept;

    [[nodiscard]] double value_at(std::int64_t sample) const noexcept;

    [[nodiscard]] bool is_finished(std::int64_t sample) const noexcept
    {
        if (note_off_ >= 0 && sample - note_off_ >= release_samples_) {
            return true;
        }
        return targets_.back() <= 0.0 && sample >= to_.back();
    }

    [[nodiscard]] std::span<const double, segment_count> targets() const noexcept
    {
        return targets_;
    }

    [[nodiscard]] std::span<const std::int64_t, segment_count> segment_ends() const noexcept
    {
        return to_;
    }
 
private:
    [[nodiscard]] double held(std::int64_t sample) const noexcept;
 
    const EnvelopeMachine* machine_;
    std::array<double, segment_count> targets_{};
    std::array<bool, segment_count> linear_{};
    std::array<std::int64_t, segment_count> from_{};
    std::array<std::int64_t, segment_count> to_{};
    std::array<double, segment_count> span_{};
 
    double release_target_ = 0.0;
    bool release_linear_ = false;
    double release_span_ = 0.0;
    std::int64_t release_samples_ = 1;
    double after_release_ = 0.0;
    std::int64_t control_tick_ = 1;
 
    std::int64_t note_off_ = -1;
    double at_note_off_ = 0.0;
};
 
} // namespace ts