capture_operation()

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

private

Definition at line 121 of file BufferPipelineCapture.cpp.

{
    if (route_image(op)) {
        return;
    }
 
    Kakshya::DataVariant buffer_data;
 
    if (op.m_capture.get_audio_buffer()) {
        bool should_process = op.m_capture.get_processing_control() == BufferCapture::ProcessingControl::ON_CAPTURE;
        buffer_data = detail::extract_buffer_data(op.m_capture.get_audio_buffer(), should_process);
    } else if (op.m_capture.get_graphics_buffer()) {
        auto graphics_data = read_graphics_buffer(op, op.m_capture.get_graphics_buffer());
        if (!graphics_data) {
            return;
        }
        buffer_data = std::move(*graphics_data);
    }
 
    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 {
                append_capture_data(it->second, buffer_data);
 
            } 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 {
                update_circular_capture(it->second, buffer_data, 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 {
                update_windowed_capture(it->second, buffer_data, window_size, hop_size);
 
            } 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_audio_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_audio_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_graphics_buffer) {
                    queue_graphics_write(*next_it, next_it->m_target_graphics_buffer, buffer_data);
                } else if (next_it->m_target_audio_stream) {
                    detail::write_to_container(next_it->m_target_audio_stream, buffer_data, next_it->m_target_audio_channel);
                } else if (next_it->m_target_graphics_stream) {
                    detail::write_to_container(next_it->m_target_graphics_stream, 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::get_audio_buffer(), MayaFlux::Kriya::BufferCapture::get_circular_size(), MayaFlux::Kriya::BufferCapture::get_graphics_buffer(), MayaFlux::Kriya::BufferCapture::get_mode(), MayaFlux::Kriya::BufferCapture::get_overlap_ratio(), MayaFlux::Kriya::BufferCapture::get_processing_control(), MayaFlux::Kriya::BufferCapture::get_window_size(), MayaFlux::Kriya::BufferOperation::m_capture, MayaFlux::Kriya::BufferCapture::m_data_ready_callback, MayaFlux::Kriya::BufferCapture::m_stop_condition, and MF_ERROR.

Referenced by process_operation().

Here is the call graph for this function:

Here is the caller graph for this function: