Class grain

include/LabSound/extended/GranulationNode.h:18–94

class GranulationNode : public AudioScheduledSourceNode
{
    struct grain
    {
        std::shared_ptr<AudioBus> sample;
        std::shared_ptr<AudioBus> window;

        bool in_use {true};

        // Values in samples
        uint64_t grain_start {0};    // frames into the sample
        uint64_t grain_duration {0}; // duration, seconds * samplerate
        uint64_t grain_end {0};      // start + duration
        uint64_t envelope_index {0};

        double playback_frequency;
        double sample_increment;
        double sample_accurate_time;  // because of double precision, it's actually subsample-accurate

        // position between 0-1, duration in seconds
        grain(std::shared_ptr<AudioBus> _sample,
              std::shared_ptr<AudioBus> _window,
              const float sample_rate,
              const double _position_offset,
              const double _duration,
              const double _speed)
        : sample(_sample), window(_window)
        {
            grain_start = static_cast<uint64_t>(sample->length() * _position_offset);
            grain_duration = static_cast<uint64_t>(_duration * sample_rate);
            grain_end = std::min(static_cast<uint64_t>(sample->length()), grain_start + grain_duration);

            playback_frequency = (1.0 / _duration) * _speed;
            sample_accurate_time = static_cast<double>((playback_frequency > 0) ? grain_start : grain_end);
            sample_increment = (playback_frequency != 0.0) ? grain_duration / (sample_rate / playback_frequency) : 0.0;
        }

        void tick(float * out_buffer, const int num_frames)
        {
            const float * windowSamples = window->channel(0)->data();

            for (int i = 0; i < num_frames; ++i)
            {
                double result = 0.f;

                if (in_use)
                {
                    sample_accurate_time += sample_increment;

                    // Looping behavior
                    if (sample_accurate_time >= grain_end)
                    {
                        sample_accurate_time = static_cast<double>(grain_start);
                    }

                    const uint64_t approximate_sample_index = static_cast<uint64_t>(std::floor(sample_accurate_time));
                    const double remainder = sample_accurate_time - approximate_sample_index;

                    uint64_t left = approximate_sample_index;
                    uint64_t right = approximate_sample_index + 1;