process()

void MayaFlux::Kakshya::WindowAccessProcessor::process ( const std::shared_ptr< SignalSourceContainer > &  container )

overridevirtual

Execute a full-surface pixel readback.

Allocates a format-appropriate DataVariant and updates container ProcessingState: PROCESSING → PROCESSED.

Implements MayaFlux::Kakshya::DataProcessor.

Definition at line 72 of file WindowAccessProcessor.cpp.

{
    auto wc = std::dynamic_pointer_cast<WindowContainer>(container);
    if (!wc) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "WindowAccessProcessor::process — container is not a WindowContainer");
        return;
    }
 
    const auto& window = wc->get_window();
 
    if (!is_readback_available(window)) {
        MF_RT_TRACE(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "WindowAccessProcessor: no completed frame available for '{}'",
            window->get_create_info().title);
        return;
    }
 
    const auto [cur_w, cur_h] = query_surface_extent(window);
    if (cur_w != m_width || cur_h != m_height) {
        m_width = cur_w;
        m_height = cur_h;
 
        m_surface_format = query_surface_format(window);
 
        MF_INFO(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "WindowAccessProcessor: '{}' resized to {}x{} format={}",
            window->get_create_info().title, m_width, m_height,
            static_cast<uint32_t>(m_surface_format));
    }
 
    m_is_processing.store(true);
    container->update_processing_state(ProcessingState::PROCESSING);
 
    auto& processed = container->get_processed_data();
    processed.resize(1);
 
    readback_region(window, 0U, 0U, m_width, m_height, processed[0]);
 
    const bool has_data = std::visit(
        [](const auto& v) { return !v.empty(); }, processed[0]);
 
    if (!has_data) {
        MF_RT_WARN(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "WindowAccessProcessor: readback returned no data for '{}'",
            window->get_create_info().title);
        m_is_processing.store(false);
        container->update_processing_state(ProcessingState::ERROR);
        return;
    }
 
    const auto* src = std::get_if<std::vector<uint8_t>>(&processed[0]);
    if (src) {
        if (uint8_t* dst = wc->mutable_frame_ptr(wc->get_write_head())) {
            std::memcpy(dst, src->data(), src->size());
            wc->advance_write_head();
        }
    }
 
    const auto vk_fmt = Core::to_vk_format(m_surface_format);
    m_last_readback_bytes = static_cast<size_t>(m_width) * m_height
        * Core::vk_format_bytes_per_pixel(vk_fmt);
 
    m_is_processing.store(false);
    container->update_processing_state(ProcessingState::PROCESSED);
}

References MayaFlux::Journal::ContainerProcessing, MayaFlux::Kakshya::ERROR, MayaFlux::Kakshya::is_readback_available(), MayaFlux::Journal::Kakshya, m_height, m_is_processing, m_last_readback_bytes, m_surface_format, m_width, MF_INFO, MF_RT_ERROR, MF_RT_TRACE, MF_RT_WARN, MayaFlux::Kakshya::PROCESSED, MayaFlux::Kakshya::PROCESSING, MayaFlux::Kakshya::query_surface_extent(), MayaFlux::Kakshya::query_surface_format(), MayaFlux::Kakshya::readback_region(), MayaFlux::Core::to_vk_format(), and MayaFlux::Core::vk_format_bytes_per_pixel().

Here is the call graph for this function: