execute_phased()

Vruta::SoundRoutine MayaFlux::Kriya::BufferPipeline::execute_phased ( uint64_t  max_cycles, uint64_t  samples_per_operation  )

private

Definition at line 790 of file BufferPipeline.cpp.

{
    auto& promise = co_await Kriya::GetAudioPromise {};
 
    if (m_operations.empty()) {
        co_return;
    }
 
    m_data_states.resize(m_operations.size(), DataState::EMPTY);
    uint32_t cycles_executed = 0;
 
    while ((max_cycles == 0 || cycles_executed < max_cycles) && (m_continuous_execution || cycles_executed < max_cycles)) {
 
        if (promise.should_terminate) {
            break;
        }
 
        if (m_cycle_start_callback) {
            m_cycle_start_callback(m_current_cycle);
        }
 
        for (auto& state : m_data_states) {
            if (state != DataState::EMPTY) {
                state = DataState::EMPTY;
            }
        }
 
        reset_accumulated_data();
 
        // ═══════════════════════════════════════════════════════
        // PHASE 1: CAPTURE - Execute all capture operations
        // ═══════════════════════════════════════════════════════
        for (size_t i = 0; i < m_operations.size(); ++i) {
            auto& op = m_operations[i];
 
            if (!BufferOperation::is_capture_phase_operation(op)) {
                continue;
            }
 
            if (op.get_type() == BufferOperation::OpType::CONDITION) {
                if (!op.m_condition || !op.m_condition(m_current_cycle)) {
                    continue;
                }
            }
 
            if (m_current_cycle % op.m_cycle_interval != 0) {
                continue;
            }
 
            uint32_t op_iterations = 1;
            if (op.get_type() == BufferOperation::OpType::CAPTURE) {
                op_iterations = op.m_capture.get_cycle_count();
            }
 
            for (uint32_t iter = 0; iter < op_iterations; ++iter) {
                process_operation(op, m_current_cycle + iter);
                if (m_capture_timing == Vruta::DelayContext::BUFFER_BASED) {
                    co_await BufferDelay { 1 };
                } else if (m_capture_timing == Vruta::DelayContext::SAMPLE_BASED && samples_per_operation > 0) {
                    co_await SampleDelay { samples_per_operation };
                }
            }
 
            m_data_states[i] = DataState::READY;
        }
 
        // ═══════════════════════════════════════════════════════
        // PHASE 2: PROCESS - Execute all processing operations
        // ═══════════════════════════════════════════════════════
 
        for (size_t i = 0; i < m_operations.size(); ++i) {
            auto& op = m_operations[i];
 
            if (!BufferOperation::is_process_phase_operation(op)) {
                continue;
            }
 
            if (m_data_states[i] == DataState::CONSUMED) {
                continue;
            }
 
            if (op.get_type() == BufferOperation::OpType::CONDITION) {
                if (!op.m_condition || !op.m_condition(m_current_cycle)) {
                    continue;
                }
            }
 
            if (m_current_cycle % op.m_cycle_interval != 0) {
                continue;
            }
 
            process_operation(op, m_current_cycle);
            m_data_states[i] = DataState::READY;
 
            if (m_process_timing == Vruta::DelayContext::BUFFER_BASED) {
                co_await BufferDelay { 1 };
            } else if (m_process_timing == Vruta::DelayContext::SAMPLE_BASED && samples_per_operation > 0) {
                co_await SampleDelay { samples_per_operation };
            }
        }
 
        // ═══════════════════════════════════════════════════════
        // Handle branches (if any)
        // ═══════════════════════════════════════════════════════
        std::vector<std::shared_ptr<Vruta::SoundRoutine>> current_cycle_sync_tasks;
 
        for (auto& branch : m_branches) {
            if (branch.condition(m_current_cycle)) {
                auto task = dispatch_branch_async(branch, m_current_cycle);
 
                if (branch.synchronous && task) {
                    current_cycle_sync_tasks.push_back(task);
                }
            }
        }
 
        if (!current_cycle_sync_tasks.empty()) {
            bool any_active = true;
            while (any_active) {
                any_active = false;
 
                for (auto& task : current_cycle_sync_tasks) {
                    if (task && task->is_active()) {
                        any_active = true;
                        break;
                    }
                }
 
                if (any_active) {
                    if (m_process_timing == Vruta::DelayContext::BUFFER_BASED) {
                        co_await BufferDelay { 1 };
                    } else {
                        co_await SampleDelay { 1 };
                    }
                }
            }
        }
 
        cleanup_completed_branches();
 
        if (m_cycle_end_callback) {
            m_cycle_end_callback(m_current_cycle);
        }
 
        cleanup_expired_data();
 
        m_current_cycle++;
        cycles_executed++;
    }
 
    if (m_on_complete)
        m_on_complete();
}

References MayaFlux::Vruta::BUFFER_BASED, MayaFlux::Kriya::BufferOperation::CAPTURE, cleanup_completed_branches(), cleanup_expired_data(), MayaFlux::Kriya::BufferOperation::CONDITION, CONSUMED, dispatch_branch_async(), EMPTY, MayaFlux::Kriya::BufferOperation::is_capture_phase_operation(), MayaFlux::Kriya::BufferOperation::is_process_phase_operation(), m_branches, m_capture_timing, m_continuous_execution, m_current_cycle, m_cycle_end_callback, m_cycle_start_callback, m_data_states, m_on_complete, m_operations, m_process_timing, process_operation(), READY, reset_accumulated_data(), and MayaFlux::Vruta::SAMPLE_BASED.

Referenced by execute_internal(), execute_parallel(), and execute_reactive().

Here is the call graph for this function:

Here is the caller graph for this function: