sampler.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/interpolator.hpp"
#include "tabulasonora/wave_descriptor.hpp"
#include "tabulasonora/wave_rom.hpp"
 
#include <cstdint>
#include <memory>
#include <span>
#include <unordered_map>
#include <vector>
 
namespace ts {

enum class SamplerMode {
    one_shot,
    loop,
    ping_pong,
};

struct DecodedWave {
    std::vector<float> samples;
    std::vector<std::int32_t> steps;
    std::int32_t seed = 0;
    int loop_start = 0;
    int data_end = 0;
    SamplerMode mode = SamplerMode::one_shot;

    std::vector<float> loop_buffer;

    bool reversed = false;

    [[nodiscard]] int loop_period() const noexcept { return data_end - loop_start + 1; }

    [[nodiscard]] bool is_looping() const noexcept
    {
        return mode == SamplerMode::loop && data_end > loop_start + 1 && !loop_buffer.empty();
    }
};

class Sampler {
public:
    Sampler(const WaveRom& rom, const Interpolator& interpolator)
        : rom_(&rom), interpolator_(&interpolator)
    {
    }

    [[nodiscard]] const DecodedWave* decode(const WaveDescriptor& descriptor);

    [[nodiscard]] std::vector<float>
    play(const DecodedWave& wave, int sample_count, double ratio) const;

    [[nodiscard]] std::vector<float>
    play_variable(const DecodedWave& wave, int sample_count, std::span<const double> ratios) const;
 
private:
    [[nodiscard]] std::unique_ptr<DecodedWave> decode_core(const WaveDescriptor& descriptor) const;
    [[nodiscard]] std::vector<float> play_at(const DecodedWave& wave,
                                             std::span<const double> positions) const;

    [[nodiscard]] static std::vector<float> build_loop_buffer(const DecodedWave& wave);

    [[nodiscard]] static std::vector<float> build_ping_pong_buffer(const DecodedWave& wave,
                                                                   int required);
 
    const WaveRom* rom_;
    const Interpolator* interpolator_;

    std::unordered_map<std::uint64_t, std::unique_ptr<DecodedWave>> cache_;
};
 
} // namespace ts