processing_function()

void MayaFlux::Buffers::FeedbackProcessor::processing_function ( const std::shared_ptr< Buffer > &  buffer )

overridevirtual

The core processing function that must be implemented by derived classes.

Parameters

buffer

Buffer to process

This method is where the actual transformation logic is implemented. It should contain the algorithmic details of how the buffer's data is transformed, analyzed, or processed. The implementation can utilize any backend capabilities available to the processor, including:

• Parallel Processing: Using multi-threading or GPU compute for large datasets
• Data Transformations: Applying mathematical operations, filters, or effects
• Feature Extraction: Analyzing data characteristics for further processing

Derived classes must override this method to provide specific processing behavior.

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 314 of file FeedbackBuffer.cpp.

{
    auto audio = std::dynamic_pointer_cast<AudioBuffer>(buffer);
    if (!audio) {
        return;
    }
 
    const bool use_step = static_cast<bool>(m_step);
    const bool use_kernel = !use_step && !m_combine && static_cast<bool>(m_kernel);
    if (!use_step && !use_kernel && !m_combine) {
        return;
    }
 
    auto& data = audio->get_data();
    const size_t samples = data.size();
    const size_t taps = m_taps.size();
    if (samples == 0 || taps == 0) {
        return;
    }
 
    State& state = state_for(buffer);
    auto& ring = *state.ring;
 
    if (ring.capacity() < m_capacity) {
        ring.resize(m_capacity);
    }
 
    if (state.values.size() != taps) {
        state.values.assign(taps, 0.0);
        state.window.assign(taps + 1, 0.0);
        state.lag_prev.assign(taps, 1.0);
        state.lag_now.assign(taps, 1.0);
        state.primed = false;
    }
 
    const auto source = m_lag_source.lock();
    const bool foreign = source && static_cast<const Buffer*>(source.get()) != buffer.get();
 
    const Memory::HistoryBuffer<double>* read_ring = &ring;
    double offset = 0.0;
    if (foreign) {
        auto& source_ring = source->get_history_buffer();
        if (source_ring.capacity() < m_capacity + samples) {
            source_ring.resize(m_capacity + samples);
        }
        read_ring = &source_ring;
        offset = static_cast<double>(source->get_write_count()) - static_cast<double>(state.elapsed);
    }
 
    const size_t extra = m_order > 1 ? m_order : 0;
    const auto rate = static_cast<double>(s_registered_sample_rate);
    const auto seconds = static_cast<double>(state.elapsed) / rate;
    const double lowest = foreign ? std::max(1.0, static_cast<double>(samples)) : 1.0;
    const double highest = std::max(static_cast<double>((foreign ? m_capacity : ring.capacity()) - extra), lowest);
 
    for (size_t t = 0; t < taps; ++t) {
        const double raw = m_taps[t].map ? (*m_taps[t].map)(seconds) * rate : m_taps[t].samples;
        state.lag_now[t] = std::clamp(raw, lowest, highest);
    }
    if (!state.primed) {
        state.lag_prev = state.lag_now;
        state.primed = true;
    }
 
    const double inverse = 1.0 / static_cast<double>(samples);
    const bool plain_read = !foreign && m_order <= 1;
 
    for (size_t i = 0; i < samples; ++i) {
        const double ramp = static_cast<double>(i + 1) * inverse;
        const double shift = foreign ? offset - static_cast<double>(i) : 0.0;
 
        for (size_t t = 0; t < taps; ++t) {
            const double lag = state.lag_prev[t] + (state.lag_now[t] - state.lag_prev[t]) * ramp;
            state.values[t] = plain_read ? read(ring, lag) : read_at(*read_ring, lag - 1.0 + shift, m_order);
        }
 
        const std::span<const double> tap_values(state.values);
        const std::span<double> coefs(state.coefs);
 
        double out {};
        double carry {};
        if (use_step) {
            const auto [step_out, step_carry] = m_step(data[i], tap_values, coefs);
            out = step_out;
            carry = step_carry;
        } else if (use_kernel) {
            state.window[0] = data[i];
            std::copy(state.values.begin(), state.values.end(), state.window.begin() + 1);
            out = m_kernel(std::span<double>(state.window), coefs);
            carry = out;
        } else {
            out = m_combine(data[i], tap_values, coefs);
            carry = out;
        }
 
        data[i] = out;
        ring.push(carry);
    }
 
    state.lag_prev = state.lag_now;
    state.elapsed += samples;
 
    if (auto owner = std::dynamic_pointer_cast<FeedbackBuffer>(buffer)) {
        owner->mark_written(samples);
    }
}

References buffer, MayaFlux::Buffers::FeedbackProcessor::State::coefs, MayaFlux::Buffers::FeedbackProcessor::State::elapsed, MayaFlux::Buffers::FeedbackProcessor::State::lag_now, MayaFlux::Buffers::FeedbackProcessor::State::lag_prev, m_capacity, m_combine, m_kernel, m_lag_source, m_order, m_step, m_taps, offset, out, MayaFlux::Buffers::FeedbackProcessor::State::primed, rate, read(), read_at(), MayaFlux::Memory::HistoryBuffer< T >::resize(), MayaFlux::Buffers::FeedbackProcessor::State::ring, MayaFlux::Buffers::s_registered_sample_rate, state_for(), MayaFlux::Buffers::FeedbackProcessor::State::values, and MayaFlux::Buffers::FeedbackProcessor::State::window.

Here is the call graph for this function: