capture_operation()

void MayaFlux::Kriya::BufferPipeline::capture_operation ( BufferOperation &  op, uint64_t  cycle  )

private

Definition at line 308 of file BufferPipeline.cpp.

{
    bool should_process = op.m_capture.get_processing_control() == BufferCapture::ProcessingControl::ON_CAPTURE;
    auto buffer_data = extract_buffer_data(op.m_capture.get_buffer(), should_process);
 
    if (op.m_capture.m_data_ready_callback) {
        op.m_capture.m_data_ready_callback(buffer_data, cycle);
    }
 
    auto capture_mode = op.m_capture.get_mode();
 
    switch (capture_mode) {
    case BufferCapture::CaptureMode::TRANSIENT:
        m_operation_data[&op] = buffer_data;
        break;
 
    case BufferCapture::CaptureMode::ACCUMULATE: {
        auto it = m_operation_data.find(&op);
        if (it == m_operation_data.end()) {
            m_operation_data[&op] = buffer_data;
        } else {
            try {
                auto& existing = std::get<std::vector<double>>(it->second);
                const auto& new_data = std::get<std::vector<double>>(buffer_data);
                existing.insert(existing.end(), new_data.begin(), new_data.end());
 
            } catch (const std::bad_variant_access& e) {
                MF_ERROR(Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    "Data type mismatch during ACCUMULATE capture: {}",
                    e.what());
                m_operation_data[&op] = buffer_data;
            }
        }
        break;
    }
    case BufferCapture::CaptureMode::CIRCULAR: {
        uint32_t circular_size = op.m_capture.get_circular_size();
        if (circular_size == 0) {
            circular_size = 4096;
        }
 
        auto it = m_operation_data.find(&op);
        if (it == m_operation_data.end()) {
            m_operation_data[&op] = buffer_data;
        } else {
            try {
                auto& circular = std::get<std::vector<double>>(it->second);
                const auto& new_data = std::get<std::vector<double>>(buffer_data);
 
                circular.insert(circular.end(), new_data.begin(), new_data.end());
 
                if (circular.size() > circular_size) {
                    circular.erase(circular.begin(),
                        circular.begin() + static_cast<int64_t>(circular.size() - circular_size));
                }
 
            } catch (const std::bad_variant_access& e) {
                MF_ERROR(Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    "Data type mismatch during CIRCULAR capture: {}",
                    e.what());
                m_operation_data[&op] = buffer_data;
            } catch (std::exception& e) {
                error_rethrow(Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    std::source_location::current(),
                    "Error during CIRCULAR capture: {}",
                    e.what());
                m_operation_data[&op] = buffer_data;
            }
        }
        break;
    }
    case BufferCapture::CaptureMode::WINDOWED: {
        uint32_t window_size = op.m_capture.get_window_size();
        float overlap_ratio = op.m_capture.get_overlap_ratio();
 
        if (window_size == 0) {
            window_size = 512;
        }
 
        auto hop_size = static_cast<uint32_t>((float)window_size * (1.0F - overlap_ratio));
        if (hop_size == 0)
            hop_size = 1;
 
        auto it = m_operation_data.find(&op);
        if (it == m_operation_data.end()) {
            m_operation_data[&op] = buffer_data;
        } else {
            try {
                auto& windowed = std::get<std::vector<double>>(it->second);
                const auto& new_data = std::get<std::vector<double>>(buffer_data);
 
                if (windowed.size() >= window_size) {
                    if (hop_size >= windowed.size()) {
                        windowed = std::get<std::vector<double>>(buffer_data);
                    } else {
                        windowed.erase(windowed.begin(),
                            windowed.begin() + hop_size);
 
                        windowed.insert(windowed.end(), new_data.begin(), new_data.end());
 
                        if (windowed.size() > window_size) {
                            size_t excess = windowed.size() - window_size;
                            windowed.erase(windowed.begin(),
                                windowed.begin() + excess);
                        }
                    }
                } else {
                    windowed.insert(windowed.end(), new_data.begin(), new_data.end());
 
                    if (windowed.size() > window_size) {
                        size_t excess = windowed.size() - window_size;
                        windowed.erase(windowed.begin(),
                            windowed.begin() + excess);
                    }
                }
 
            } catch (const std::bad_variant_access& e) {
                MF_ERROR(Journal::Component::Kriya, Journal::Context::CoroutineScheduling,
                    "Data type mismatch during WINDOWED capture: {}", e.what());
                m_operation_data[&op] = buffer_data;
            }
        }
        break;
    }
 
    case BufferCapture::CaptureMode::TRIGGERED: {
        if (op.m_capture.m_stop_condition && op.m_capture.m_stop_condition()) {
            m_operation_data[&op] = buffer_data;
        }
        break;
    }
 
    default:
        m_operation_data[&op] = buffer_data;
        break;
    }
 
    if (has_immediate_routing(op)) {
        auto current_it = std::ranges::find_if(m_operations,
            [&op](const BufferOperation& o) { return &o == &op; });
 
        if (current_it != m_operations.end()) {
            auto next_it = std::next(current_it);
            if (next_it != m_operations.end() && next_it->get_type() == BufferOperation::OpType::ROUTE) {
 
                if (next_it->m_target_buffer) {
                    if (!m_buffer_manager) {
                        error<std::invalid_argument>(Journal::Component::Kriya,
                            Journal::Context::CoroutineScheduling,
                            std::source_location::current(),
                            "BufferPipeline has no BufferManager for immediate ROUTE-to-buffer");
                    }
 
                    if (!next_it->m_attached_processor) {
                        auto writer = std::make_shared<Buffers::AudioWriteProcessor>();
                        m_buffer_manager->add_processor(writer, next_it->m_target_buffer,
                            Buffers::ProcessingToken::AUDIO_BACKEND);
                        next_it->m_attached_processor = writer;
                    }
 
                    std::static_pointer_cast<Buffers::AudioWriteProcessor>(next_it->m_attached_processor)
                        ->set_data(buffer_data);
                } else if (next_it->m_target_container) {
                    write_to_container(next_it->m_target_container, buffer_data);
                }
 
                size_t route_index = std::distance(m_operations.begin(), next_it);
                if (route_index < m_data_states.size()) {
                    m_data_states[route_index] = DataState::CONSUMED;
                }
            }
        }
    }
}

References MayaFlux::Kriya::BufferCapture::ACCUMULATE, MayaFlux::Buffers::AUDIO_BACKEND, MayaFlux::Kriya::BufferCapture::CIRCULAR, CONSUMED, MayaFlux::Journal::CoroutineScheduling, extract_buffer_data(), MayaFlux::Kriya::BufferCapture::get_buffer(), MayaFlux::Kriya::BufferCapture::get_circular_size(), MayaFlux::Kriya::BufferCapture::get_mode(), MayaFlux::Kriya::BufferCapture::get_overlap_ratio(), MayaFlux::Kriya::BufferCapture::get_processing_control(), MayaFlux::Kriya::BufferCapture::get_window_size(), has_immediate_routing(), MayaFlux::Journal::Kriya, m_buffer_manager, MayaFlux::Kriya::BufferOperation::m_capture, MayaFlux::Kriya::BufferCapture::m_data_ready_callback, m_data_states, m_operation_data, m_operations, MayaFlux::Kriya::BufferCapture::m_stop_condition, MF_ERROR, MayaFlux::Kriya::BufferCapture::ON_CAPTURE, MayaFlux::Kriya::BufferOperation::ROUTE, MayaFlux::Kriya::BufferCapture::TRANSIENT, MayaFlux::Kriya::BufferCapture::TRIGGERED, MayaFlux::Kriya::BufferCapture::WINDOWED, and write_to_container().

Referenced by process_operation().

Here is the call graph for this function:

Here is the caller graph for this function: