start_readback_thread()

void MayaFlux::Core::BackendWindowHandler::start_readback_thread ( CaptureState &  state, vk::Device  dev  )

private

Thread function to perform asynchronous readback of captured frames.

Parameters

state	Capture state containing pending readbacks
dev	Vulkan device to use for readback operations

This thread continuously checks for pending capture slots and performs the necessary Vulkan commands to read back the image data into CPU memory. The last captured frame is stored atomically for retrieval by the display service.

Definition at line 1060 of file BackendWindowHandler.cpp.

{
    state.readback_running.store(true, std::memory_order_release);
 
    state.readback_thread = std::thread([&state, dev]() {
        while (state.readback_running.load(std::memory_order_acquire)) {
            bool any = false;
 
            for (auto& slot_ptr : state.slots) {
                auto& slot = *slot_ptr;
 
                if (!slot.pending.load(std::memory_order_acquire))
                    continue;
 
                if (dev.getFenceStatus(slot.fence) != vk::Result::eSuccess)
                    continue;
 
                const size_t nb = static_cast<size_t>(slot.extent.width)
                    * slot.extent.height * state.bpp;
 
                vk::SubresourceLayout layout = dev.getImageSubresourceLayout(
                    slot.image, { vk::ImageAspectFlagBits::eColor, 0, 0 });
 
                const auto* mapped = static_cast<const uint8_t*>(
                    dev.mapMemory(slot.mem, 0, VK_WHOLE_SIZE));
                mapped += layout.offset;
 
                auto buf = std::make_shared<std::vector<uint8_t>>(nb);
                const uint32_t row_bytes = slot.extent.width * state.bpp;
                for (uint32_t y = 0; y < slot.extent.height; ++y) {
                    std::memcpy(buf->data() + static_cast<size_t>(y * row_bytes),
                        mapped + y * layout.rowPitch,
                        row_bytes);
                }
 
                dev.unmapMemory(slot.mem);
 
                // ---------------------------------------------------------------
                // Store new frame into last_frame (same pattern as InputManager)
                // ---------------------------------------------------------------
#ifdef MAYAFLUX_PLATFORM_MACOS
                auto* raw_frame = new std::vector<uint8_t>(*buf);
                auto* old = state.last_frame.exchange(raw_frame, std::memory_order_acq_rel);
                if (old)
                    state.retire_last_frame(old);
#else
                state.last_frame.store(buf, std::memory_order_release);
#endif
 
// ---------------------------------------------------------------
// Read observers and invoke callbacks
// ---------------------------------------------------------------
#ifdef MAYAFLUX_PLATFORM_MACOS
                size_t obs_slot = CaptureState::OBSERVERS_MAX_READERS;
                for (size_t i = 0; i < CaptureState::OBSERVERS_MAX_READERS; ++i) {
                    bool expected = false;
                    if (state.observers_slot_active[i].compare_exchange_strong(expected, true, std::memory_order_acquire)) {
                        obs_slot = i;
                        break;
                    }
                }
 
                if (obs_slot != CaptureState::OBSERVERS_MAX_READERS) {
                    const CaptureState::ObserverMap* obs_current;
                    do {
                        obs_current = state.observers.load(std::memory_order_acquire);
                        state.observers_hazard_ptrs[obs_slot].store(obs_current, std::memory_order_release);
                    } while (obs_current != state.observers.load(std::memory_order_acquire));
 
                    if (obs_current) {
                        for (const auto& [id, cb] : *obs_current) {
                            cb(buf, slot.extent.width, slot.extent.height,
                                static_cast<uint32_t>(state.format));
                        }
                    }
 
                    state.observers_hazard_ptrs[obs_slot].store(nullptr, std::memory_order_release);
                    state.observers_slot_active[obs_slot].store(false, std::memory_order_release);
                }
#else
                auto obs = state.observers.load(std::memory_order_acquire);
                if (obs) {
                    for (const auto& [id, cb] : *obs) {
                        cb(buf, slot.extent.width, slot.extent.height,
                            static_cast<uint32_t>(state.format));
                    }
                }
#endif
 
                slot.pending.store(false, std::memory_order_release);
                any = true;
            }
 
            if (!any)
                std::this_thread::sleep_for(std::chrono::microseconds(200));
        }
    });
}

References MayaFlux::Core::CaptureState::readback_running, and MayaFlux::Core::CaptureState::readback_thread.