capture_frame()

void MayaFlux::Core::BackendWindowHandler::capture_frame ( WindowRenderContext &  ctx )

private

Capture the current frame from a window's swapchain.

Parameters

ctx	Window render context to capture from

This initiates an asynchronous readback of the current swapchain image into CPU-accessible memory. The result is stored in the capture state for retrieval via the display service.

Definition at line 914 of file BackendWindowHandler.cpp.

{
    if (!ctx.swapchain || ctx.window->get_rendering_buffers().empty()
        || !ctx.window->is_capture_enabled())
        return;
 
    auto dev = m_context.get_device();
    const auto ext = ctx.swapchain->get_extent();
    const vk::Format fmt = ctx.swapchain->get_image_format();
    const uint32_t bpp = Core::vk_format_bytes_per_pixel(fmt);
    const vk::Image src = ctx.swapchain->get_images()[ctx.current_image_index];
 
    if (!ctx.capture) {
        ensure_capture_state(ctx);
    }
 
    auto& slot = *ctx.capture->slots[ctx.capture->slot_index];
 
    if (slot.pending.load(std::memory_order_acquire))
        return;
 
    if (slot.image && slot.extent != ext) {
        dev.destroyImage(slot.image);
        dev.freeMemory(slot.mem);
        slot.image = vk::Image {};
        slot.mem = vk::DeviceMemory {};
    }
 
    if (!slot.image) {
        vk::ImageCreateInfo ici {};
        ici.imageType = vk::ImageType::e2D;
        ici.format = fmt;
        ici.extent = vk::Extent3D { ext.width, ext.height, 1 };
        ici.arrayLayers = 1;
        ici.mipLevels = 1;
        ici.samples = vk::SampleCountFlagBits::e1;
        ici.tiling = vk::ImageTiling::eLinear;
        ici.usage = vk::ImageUsageFlagBits::eTransferDst;
 
        slot.image = dev.createImage(ici);
 
        auto req = dev.getImageMemoryRequirements(slot.image);
        vk::MemoryAllocateInfo mai {};
        mai.allocationSize = req.size;
        mai.memoryTypeIndex = m_resource_manager->find_memory_type(
            req.memoryTypeBits,
            vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);
 
        slot.mem = dev.allocateMemory(mai);
        dev.bindImageMemory(slot.image, slot.mem, 0);
        slot.extent = ext;
    }
 
    slot.cmd.reset({});
    vk::CommandBufferBeginInfo bi {};
    bi.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;
    slot.cmd.begin(bi);
 
    vk::ImageMemoryBarrier b {};
    b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    b.subresourceRange = { vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1 };
 
    b.image = slot.image;
    b.oldLayout = vk::ImageLayout::eUndefined;
    b.newLayout = vk::ImageLayout::eTransferDstOptimal;
    b.srcAccessMask = {};
    b.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
    slot.cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
        vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, b);
 
    b.image = src;
    b.oldLayout = vk::ImageLayout::ePresentSrcKHR;
    b.newLayout = vk::ImageLayout::eTransferSrcOptimal;
    b.srcAccessMask = vk::AccessFlagBits::eMemoryRead;
    b.dstAccessMask = vk::AccessFlagBits::eTransferRead;
    slot.cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
        vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, b);
 
    vk::ImageCopy copy {};
    copy.srcSubresource = { vk::ImageAspectFlagBits::eColor, 0, 0, 1 };
    copy.dstSubresource = { vk::ImageAspectFlagBits::eColor, 0, 0, 1 };
    copy.extent = vk::Extent3D { ext.width, ext.height, 1 };
    slot.cmd.copyImage(src, vk::ImageLayout::eTransferSrcOptimal,
        slot.image, vk::ImageLayout::eTransferDstOptimal, 1, &copy);
 
    b.image = slot.image;
    b.oldLayout = vk::ImageLayout::eTransferDstOptimal;
    b.newLayout = vk::ImageLayout::eGeneral;
    b.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
    b.dstAccessMask = vk::AccessFlagBits::eMemoryRead;
    slot.cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
        vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, b);
 
    b.image = src;
    b.oldLayout = vk::ImageLayout::eTransferSrcOptimal;
    b.newLayout = vk::ImageLayout::ePresentSrcKHR;
    b.srcAccessMask = vk::AccessFlagBits::eTransferRead;
    b.dstAccessMask = vk::AccessFlagBits::eMemoryRead;
    slot.cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
        vk::PipelineStageFlagBits::eTransfer, {}, {}, {}, b);
 
    slot.cmd.end();
 
    (void)dev.resetFences(1, &slot.fence);
 
    vk::SubmitInfo si {};
    si.commandBufferCount = 1;
    si.pCommandBuffers = &slot.cmd;
 
    slot.pending.store(true, std::memory_order_release);
 
    if (auto result = m_context.get_graphics_queue().submit(1, &si, slot.fence); result != vk::Result::eSuccess) {
        MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
            "Failed to submit capture command buffer for window '{}': {}",
            ctx.window->get_create_info().title, vk::to_string(result));
        slot.pending.store(false, std::memory_order_release);
        return;
    }
 
    ctx.capture->slot_index = (ctx.capture->slot_index + 1) % ctx.capture->slots.size();
}

References b, MayaFlux::Core::WindowRenderContext::capture, MayaFlux::Journal::Core, MayaFlux::Core::WindowRenderContext::current_image_index, MayaFlux::Journal::GraphicsCallback, MF_RT_ERROR, MayaFlux::Core::WindowRenderContext::swapchain, MayaFlux::Core::vk_format_bytes_per_pixel(), and MayaFlux::Core::WindowRenderContext::window.

Here is the call graph for this function: