IOManager.cpp

Go to the documentation of this file.

#include "IOManager.hpp"
 
#include "Detail/IOTransitions.hpp"
 
#include "MayaFlux/Buffers/BufferManager.hpp"
#include "MayaFlux/Core/Backends/Windowing/Window.hpp"
 
#include "MayaFlux/Kakshya/Source/DynamicSoundStream.hpp"
 
#include "MayaFlux/Nodes/Network/MeshNetwork.hpp"
 
#include "MayaFlux/Kakshya/Source/AudioOutputContainer.hpp"
#include "MayaFlux/Kakshya/Source/CameraContainer.hpp"
#include "MayaFlux/Kakshya/Source/CompositeContainer.hpp"
#include "MayaFlux/Kakshya/Source/DynamicVideoStream.hpp"
#include "MayaFlux/Kakshya/Source/SoundFileContainer.hpp"
#include "MayaFlux/Kakshya/Source/VideoFileContainer.hpp"
 
#include "Audio/SoundFileWriter.hpp"
#include "Camera/CameraSource.hpp"
#include "Camera/FFmpegCameraReader.hpp"
#include "Composite/CompositeReader.hpp"
#include "Composite/CompositeWriter.hpp"
#include "Video/VideoFileWriter.hpp"
#include "Volume/VolumeTransfer.hpp"
 
#include "MayaFlux/Buffers/Container/SoundContainerBuffer.hpp"
#include "MayaFlux/Buffers/Container/VideoContainerBuffer.hpp"
#include "MayaFlux/Buffers/Textures/TextureBuffer.hpp"
 
#include "MayaFlux/Buffers/Geometry/MeshBuffer.hpp"
#include "MayaFlux/Buffers/State/VolumeGridBuffer.hpp"
#include "MayaFlux/Buffers/Textures/TextBuffer.hpp"
 
#include "MayaFlux/Registry/BackendRegistry.hpp"
#include "MayaFlux/Registry/Service/AudioBackendService.hpp"
#include "MayaFlux/Registry/Service/IOService.hpp"
 
#include "Composite/DelimitedTextReader.hpp"
#include "Composite/DelimitedTextWriter.hpp"
 
#include "Image/EXRWriter.hpp"
#include "Image/ImageExport.hpp"
#include "Image/STBImageWriter.hpp"
 
#include "Model/AssimpModelWriter.hpp"
#include "Model/ModelExport.hpp"
#include "Model/ModelReader.hpp"
 
#include "Volume/VDBWriter.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
extern "C" {
#include <libavdevice/avdevice.h>
}
 
namespace MayaFlux::IO {
 
IOManager::IOManager(Core::GlobalStreamInfo& stream_info, uint32_t frame_rate, const std::shared_ptr<Buffers::BufferManager>& buffer_manager, const std::shared_ptr<Vruta::TaskScheduler>& scheduler)
    : m_stream_info(stream_info)
    , m_frame_rate(frame_rate)
    , m_buffer_manager(buffer_manager)
    , m_scheduler(scheduler)
    , m_save_tasks([](std::exception_ptr ep) {
        try {
            std::rethrow_exception(std::move(ep));
        } catch (...) {
            try {
                Journal::error_rethrow(Journal::Component::IO, Journal::Context::FileIO,
                    std::source_location::current(), "save task failed");
            }
            // NOLINTNEXTLINE(bugprone-empty-catch)
            catch (...) {
            }
        }
    })
{
    m_io_service = std::make_shared<Registry::Service::IOService>();
 
    m_io_service->request_decode = [this](uint64_t reader_id) {
        dispatch_decode_request(reader_id);
    };
 
    Registry::BackendRegistry::instance()
        .register_service<Registry::Service::IOService>(
            [svc = m_io_service]() -> void* { return svc.get(); });
 
    m_io_service->request_frame = [this](uint64_t reader_id) {
        dispatch_frame_request(reader_id);
    };
 
    STBImageWriter::register_with_registry();
    EXRWriter::register_with_registry();
    VDBWriter::register_with_registry();
    AssimpModelWriter::register_with_registry();
 
    MF_INFO(Journal::Component::Core, Journal::Context::Init, "IOManager initialised");
}
 
IOManager::~IOManager()
{
    shutdown();
}
 
void IOManager::stop()
{
    if (m_stop_done.exchange(true)) {
        return;
    }
 
    {
        std::vector<uint32_t> ids;
        {
            std::lock_guard lock(m_audio_captures_mutex);
            ids.reserve(m_audio_captures.size());
            for (const auto& [id, _] : m_audio_captures)
                ids.push_back(id);
        }
        for (auto id : ids)
            stop_audio_capture(id);
    }
 
    {
        std::vector<uint32_t> ids;
        {
            std::lock_guard lock(m_video_captures_mutex);
            ids.reserve(m_video_captures.size());
            for (const auto& [id, _] : m_video_captures)
                ids.push_back(id);
        }
        for (auto id : ids)
            stop_video_capture(id);
    }
 
    {
        std::vector<uint32_t> ids;
        {
            std::lock_guard lock(m_volume_captures_mutex);
            ids.reserve(m_volume_captures.size());
            for (const auto& [id, _] : m_volume_captures)
                ids.push_back(id);
        }
        for (auto id : ids)
            stop_volume_capture(id);
    }
 
    {
        std::vector<uint32_t> ids;
        {
            std::lock_guard lock(m_spatial_captures_mutex);
            ids.reserve(m_spatial_captures.size());
            for (const auto& [id, _] : m_spatial_captures)
                ids.push_back(id);
        }
        for (auto id : ids)
            stop_spatial_capture(id);
    }
 
    for (auto& w : m_writers) {
        if (w->is_open()) {
            auto fut = w->close();
            fut.wait();
        }
    }
 
    wait_for_pending_saves();
 
    MF_TRACE(Journal::Component::IO, Journal::Context::Init, "IOManager stopped");
}
 
void IOManager::shutdown()
{
    if (m_shutdown_done.exchange(true)) {
        return;
    }
 
    stop();
 
    wait_for_pending_saves();
 
    Registry::BackendRegistry::instance()
        .unregister_service<Registry::Service::IOService>();
 
    m_io_service.reset();
 
    {
        decltype(m_video_readers) video_readers;
        {
            std::unique_lock lock(m_readers_mutex);
            video_readers = std::exchange(m_video_readers, {});
        }
 
        decltype(m_camera_readers) camera_readers;
        decltype(m_camera_buffers) camera_buffers;
        {
            std::unique_lock lock(m_camera_mutex);
            camera_readers = std::exchange(m_camera_readers, {});
            camera_buffers = std::exchange(m_camera_buffers, {});
        }
 
        decltype(m_video_buffers) video_buffers;
        decltype(m_audio_buffers) audio_buffers;
        decltype(m_extracted_audio) extracted_audio;
        {
            std::unique_lock lock(m_buffers_mutex);
            video_buffers = std::exchange(m_video_buffers, {});
            audio_buffers = std::exchange(m_audio_buffers, {});
            extracted_audio = std::exchange(m_extracted_audio, {});
        }
 
        decltype(m_writers) writers;
        {
            std::lock_guard lock(m_writers_mutex);
            writers = std::exchange(m_writers, {});
        }
 
        decltype(m_video_writers) video_writers;
        {
            std::lock_guard lock(m_video_captures_mutex);
            video_writers = std::exchange(m_video_writers, {});
        }
 
        decltype(m_spatial_caches) spatial_caches;
        {
            std::lock_guard lock(m_spatial_captures_mutex);
            spatial_caches = std::exchange(m_spatial_caches, {});
            m_spatial_cache_refcounts.clear();
        }
 
        auto loaded_volumes = std::exchange(m_loaded_volumes, {});
        auto audio_readers = std::exchange(m_audio_readers, {});
        auto image_readers = std::exchange(m_image_readers, {});
        auto model_readers = std::exchange(m_model_readers, {});
 
        video_readers.clear();
        camera_readers.clear();
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::Init, "IOManager shutdown complete");
}
 
std::shared_ptr<Kakshya::VideoFileContainer>
IOManager::load_video(const std::string& filepath)
{
    auto [video, audio] = load_video(filepath, {});
    return std::move(video);
}
 
VideoLoadResult
IOManager::load_video(const std::string& filepath, VideoLoadConfig config)
{
    auto reader = std::make_shared<IO::VideoFileReader>();
 
    if (!reader->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Cannot read video file: {}", filepath);
        return {};
    }
 
    reader->set_video_options(config.video_options);
    reader->set_audio_options(config.audio_options);
    reader->set_target_dimensions(config.target_width, config.target_height);
 
    if ((config.video_options & VideoReadOptions::EXTRACT_AUDIO) == VideoReadOptions::EXTRACT_AUDIO) {
        reader->set_target_sample_rate(m_stream_info.sample_rate);
    }
 
    if (!reader->open(filepath, config.file_options)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Failed to open video file: {}", reader->get_last_error());
        return {};
    }
 
    const uint64_t reader_id = register_video_reader(reader);
    reader->setup_io_service(reader_id);
 
    auto video_container = std::dynamic_pointer_cast<Kakshya::VideoFileContainer>(reader->create_container());
 
    if (!video_container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "Failed to create video container from: {}", filepath);
        release_video_reader(reader_id);
        return {};
    }
 
    if (!reader->load_into_container(video_container)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Failed to load video data: {}", reader->get_last_error());
        release_video_reader(reader_id);
        return {};
    }
 
    configure_frame_processor(video_container);
 
    std::shared_ptr<Kakshya::SoundFileContainer> audio_container;
 
    if ((config.video_options & IO::VideoReadOptions::EXTRACT_AUDIO) == IO::VideoReadOptions::EXTRACT_AUDIO) {
        audio_container = reader->get_audio_container();
        if (audio_container) {
            configure_audio_processor(audio_container);
            m_extracted_audio[video_container] = audio_container;
        } else {
            MF_WARN(Journal::Component::API, Journal::Context::FileIO,
                "No audio track found in: {}", filepath);
        }
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "Loaded video: {}", filepath);
 
    return { std::move(video_container), std::move(audio_container) };
}
 
uint64_t IOManager::register_video_reader(std::shared_ptr<IO::VideoFileReader> reader)
{
    if (!reader) {
        MF_WARN(Journal::Component::Core, Journal::Context::FileIO,
            "IOManager::register_video_reader called with null reader");
        return 0;
    }
 
    const uint64_t id = m_next_reader_id.fetch_add(1, std::memory_order_relaxed);
    reader->set_reader_id(id);
 
    {
        std::unique_lock lock(m_readers_mutex);
        m_video_readers.emplace(id, std::move(reader));
    }
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::FileIO,
        "IOManager: registered VideoFileReader id={}", id);
 
    return id;
}
 
void IOManager::release_video_reader(uint64_t reader_id)
{
    std::unique_lock lock(m_readers_mutex);
    auto it = m_video_readers.find(reader_id);
 
    if (it == m_video_readers.end()) {
        MF_WARN(Journal::Component::Core, Journal::Context::FileIO,
            "IOManager::release_video_reader: unknown id={}", reader_id);
        return;
    }
 
    m_video_readers.erase(it);
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::FileIO,
        "IOManager: released VideoFileReader id={}", reader_id);
}
 
void IOManager::dispatch_decode_request(uint64_t reader_id)
{
    std::shared_lock lock(m_readers_mutex);
    auto it = m_video_readers.find(reader_id);
 
    if (it == m_video_readers.end()) {
        MF_WARN(Journal::Component::Core, Journal::Context::AsyncIO,
            "IOManager: dispatch_decode_request unknown reader_id={}", reader_id);
        return;
    }
 
    it->second->signal_decode();
}
 
void IOManager::dispatch_frame_request(uint64_t reader_id)
{
    std::shared_lock lock(m_camera_mutex);
    auto it = m_camera_readers.find(reader_id);
 
    if (it == m_camera_readers.end()) {
        MF_WARN(Journal::Component::Core, Journal::Context::AsyncIO,
            "IOManager: dispatch_frame_request unknown reader_id={}", reader_id);
        return;
    }
 
    it->second->pull_frame_all();
}
 
uint64_t IOManager::register_camera_source(std::shared_ptr<CameraSource> source)
{
    if (!source) {
        MF_WARN(Journal::Component::Core, Journal::Context::FileIO,
            "IOManager::register_camera_source called with null source");
        return 0;
    }
 
    const uint64_t id = m_next_reader_id.fetch_add(1, std::memory_order_relaxed);
 
    {
        std::unique_lock lock(m_camera_mutex);
        m_camera_readers.emplace(id, std::move(source));
    }
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::FileIO,
        "IOManager: registered CameraSource id={}", id);
 
    return id;
}
 
void IOManager::release_camera_source(uint64_t reader_id)
{
    std::unique_lock lock(m_camera_mutex);
    auto it = m_camera_readers.find(reader_id);
 
    if (it == m_camera_readers.end()) {
        MF_WARN(Journal::Component::Core, Journal::Context::FileIO,
            "IOManager::release_camera_source: unknown id={}", reader_id);
        return;
    }
 
    m_camera_readers.erase(it);
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::FileIO,
        "IOManager: released CameraSource id={}", reader_id);
}
 
std::shared_ptr<Kakshya::SoundFileContainer> IOManager::load_audio(const std::string& filepath, VideoLoadConfig config)
{
    auto reader = std::make_shared<IO::SoundFileReader>();
 
    if (!reader->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO, "Cannot read file: {}", filepath);
        return nullptr;
    }
 
    reader->set_target_sample_rate(m_stream_info.sample_rate);
    reader->set_audio_options(config.audio_options);
 
    if (!reader->open(filepath, config.file_options)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO, "Failed to open file: {}", reader->get_last_error());
        return nullptr;
    }
 
    auto container = reader->create_container();
    auto sound_container = std::dynamic_pointer_cast<Kakshya::SoundFileContainer>(container);
    if (!sound_container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime, "Failed to create sound container");
        return nullptr;
    }
 
    if (!reader->load_into_container(sound_container)) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime, "Failed to load audio data: {}", reader->get_last_error());
        return nullptr;
    }
 
    configure_audio_processor(sound_container);
 
    m_audio_readers.push_back(std::move(reader));
 
    return sound_container;
}
 
std::shared_ptr<Kakshya::DynamicSoundStream> IOManager::load_audio_bounded(
    const std::string& filepath,
    uint64_t max_frames,
    bool truncate)
{
    auto reader = std::make_shared<IO::SoundFileReader>();
 
    if (!reader->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_bounded: unsupported format '{}'", filepath);
        return nullptr;
    }
 
    reader->set_target_sample_rate(m_stream_info.sample_rate);
 
    auto stream = reader->load_bounded(filepath, max_frames, truncate);
    if (!stream) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_bounded: failed for '{}'", filepath);
        return nullptr;
    }
 
    stream->set_memory_layout(Kakshya::MemoryLayout::ROW_MAJOR);
 
    m_audio_readers.push_back(std::move(reader));
 
    return stream;
}
 
// ─────────────────────────────────────────────────────────────────────────
 
std::shared_ptr<SoundFileWriter>
IOManager::create_writer(const std::string& filepath,
    uint32_t channels,
    uint32_t sample_rate,
    AVCodecID codec_id)
{
    auto writer = std::make_shared<SoundFileWriter>();
    if (!writer->open(filepath, channels, sample_rate, codec_id)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "create_writer: open failed for '{}': {}", filepath, writer->last_error());
        return nullptr;
    }
 
    {
        std::lock_guard lock(m_writers_mutex);
        m_writers.push_back(writer);
    }
    return writer;
}
 
void IOManager::write(const std::shared_ptr<Kakshya::SoundStreamContainer>& container,
    const std::string& filepath,
    AVCodecID codec_id)
{
    if (!container) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write: null container");
        return;
    }
 
    auto writer = std::make_shared<SoundFileWriter>();
    if (!writer->open(filepath,
            container->get_num_channels(),
            container->get_sample_rate(),
            codec_id)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "write: open failed for '{}': {}", filepath, writer->last_error());
        return;
    }
 
    writer->write(container->get_data());
    track_save_task(writer->close());
}
 
uint32_t IOManager::capture_output(const std::string& filepath, AVCodecID codec_id)
{
 
    if (!m_audio_backend_service) {
        m_audio_backend_service = Registry::BackendRegistry::instance()
                                      .get_service<Registry::Service::AudioBackendService>();
    }
 
    if (!m_audio_backend_service) {
        error<std::runtime_error>(Journal::Component::IO, Journal::Context::FileIO, std::source_location::current(),
            "capture_output: AudioBackendService unavailable");
    }
 
    auto ct = std::make_shared<Kakshya::AudioOutputContainer>(m_stream_info);
    ct->create_default_processor();
 
    auto writer = std::make_shared<SoundFileWriter>();
    if (!writer->open(filepath,
            m_stream_info.output.channels,
            m_stream_info.sample_rate,
            codec_id)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_output: writer open failed for '{}': {}", filepath, writer->last_error());
        return 0;
    }
 
    uint32_t obs_id = m_audio_backend_service->register_output_observer(
        [ct, writer](const double*, uint32_t) {
            ct->process_default();
            const auto& vt = ct->get_processed_data();
            if (!vt.empty())
                writer->write(vt);
        });
 
    {
        std::lock_guard lock(m_writers_mutex);
        m_writers.push_back(writer);
    }
 
    std::lock_guard lock(m_audio_captures_mutex);
    m_audio_captures.emplace(obs_id, AudioCaptureState { .container = ct, .writer = writer, .observer_id = obs_id });
    return obs_id;
}
 
void IOManager::stop_audio_capture(uint32_t capture_id)
{
    AudioCaptureState state;
    {
        std::lock_guard lock(m_audio_captures_mutex);
        auto it = m_audio_captures.find(capture_id);
        if (it == m_audio_captures.end()) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "stop_audio_capture: unknown capture_id={}", capture_id);
            return;
        }
        state = std::move(it->second);
        m_audio_captures.erase(it);
    }
 
    auto* svc = Registry::BackendRegistry::instance()
                    .get_service<Registry::Service::AudioBackendService>();
    if (svc)
        svc->unregister_output_observer(state.observer_id);
 
    track_save_task(state.writer->close());
}
 
std::vector<uint32_t> IOManager::get_audio_capture_ids() const
{
    std::lock_guard lock(m_audio_captures_mutex);
    std::vector<uint32_t> ids;
    ids.reserve(m_audio_captures.size());
    for (const auto& [id, _] : m_audio_captures)
        ids.push_back(id);
    return ids;
}
 
std::shared_ptr<VideoFileWriter>
IOManager::create_writer(const std::string& filepath,
    uint32_t width,
    uint32_t height,
    double frame_rate,
    AVPixelFormat src_pixel_format,
    AVCodecID codec_id)
{
    auto writer = std::make_shared<VideoFileWriter>();
    if (!writer->open(filepath, width, height, frame_rate, src_pixel_format, codec_id)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "create_writer: open failed for '{}': {}", filepath, writer->last_error());
        return nullptr;
    }
    return writer;
}
 
uint32_t IOManager::capture_window(
    const std::shared_ptr<Core::Window>& window,
    const std::string& filepath,
    double frame_rate,
    AVCodecID codec_id)
{
    if (!window) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_window: null window");
        return 0;
    }
 
    auto writer = std::make_shared<VideoFileWriter>();
    if (!writer->record(window, filepath, frame_rate, codec_id)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_window: record failed for '{}': {}", filepath, writer->last_error());
        return 0;
    }
 
    const uint32_t id = m_next_video_capture_id.fetch_add(1, std::memory_order_relaxed);
 
    {
        std::lock_guard lock(m_video_captures_mutex);
        m_video_captures.emplace(id, VideoCaptureState { .writer = writer, .capture_id = id });
        m_video_writers.push_back(writer);
    }
 
    return id;
}
 
void IOManager::stop_video_capture(uint32_t capture_id)
{
    VideoCaptureState state;
    {
        std::lock_guard lock(m_video_captures_mutex);
        auto it = m_video_captures.find(capture_id);
        if (it == m_video_captures.end()) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "stop_video_capture: unknown capture_id={}", capture_id);
            return;
        }
        state = std::move(it->second);
        m_video_captures.erase(it);
    }
 
    track_save_task(state.writer->stop_recording());
}
 
void IOManager::stop_capture(const std::shared_ptr<Core::Window>& window)
{
    if (!window) {
        MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
            "stop_capture(window): null window");
        return;
    }
 
    uint32_t found_id = 0;
    {
        std::lock_guard lock(m_video_captures_mutex);
        for (const auto& [id, state] : m_video_captures) {
            if (state.writer->capture_window() == window) {
                found_id = id;
                break;
            }
        }
    }
 
    if (found_id == 0) {
        MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
            "stop_capture(window): no active capture for window '{}'",
            window->get_create_info().title);
        return;
    }
 
    stop_video_capture(found_id);
}
 
std::vector<uint32_t> IOManager::get_video_capture_ids() const
{
    std::lock_guard lock(m_video_captures_mutex);
    std::vector<uint32_t> ids;
    ids.reserve(m_video_captures.size());
    for (const auto& [id, _] : m_video_captures)
        ids.push_back(id);
    return ids;
}
 
std::vector<std::shared_ptr<VideoFileWriter>> IOManager::get_video_writers() const
{
    std::lock_guard lock(m_video_captures_mutex);
    return m_video_writers;
}
 
std::shared_ptr<Kakshya::CameraContainer>
IOManager::open_camera(const CameraConfig& config)
{
    static std::once_flag s_avdevice_init;
    std::call_once(s_avdevice_init, [] { avdevice_register_all(); });
 
    auto reader = std::make_shared<FFmpegCameraReader>();
 
    if (!reader->open(config)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "open_camera: failed — {}", reader->last_error());
        return nullptr;
    }
 
    auto container = reader->create_container();
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "open_camera: failed to create container — {}",
            reader->last_error());
        return nullptr;
    }
 
    container->create_default_processor();
    reader->set_container(container);
 
    const uint64_t rid = register_camera_source(reader);
    Detail::configure_camera_container(container, rid);
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "open_camera: reader_id={} device='{}' {}x{} @{:.1f}fps",
        rid, config.device_name,
        reader->width(), reader->height(), reader->frame_rate());
 
    return container;
}
 
std::shared_ptr<Buffers::TextureBuffer>
IOManager::load_image(const std::string& filepath, int desired_channels,
    std::optional<Kakshya::Region> region)
{
    auto reader = std::make_shared<IO::ImageReader>(desired_channels, std::move(region));
 
    if (!reader->open(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Failed to open image: {}", filepath);
        return nullptr;
    }
 
    auto texture_buffer = reader->create_texture_buffer();
 
    if (!texture_buffer) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Failed to create texture buffer from: {}", filepath);
        return nullptr;
    }
 
    m_image_readers.push_back(std::move(reader));
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "Loaded image: {} ({}x{})",
        std::filesystem::path(filepath).filename().string(),
        texture_buffer->get_width(),
        texture_buffer->get_height());
 
    return texture_buffer;
}
 
std::shared_ptr<CompositeReader>
IOManager::open_composite_reader(
    const std::string& filepath,
    std::optional<Kakshya::CompositeLayout> layout)
{
    auto delimited = std::make_shared<DelimitedTextReader>();
    if (!delimited->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::open_composite_reader: unsupported format '{}'", filepath);
        return nullptr;
    }
 
    if (layout && !delimited->set_layout(std::move(*layout))) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::open_composite_reader: failed to set layout for '{}'", filepath);
        return nullptr;
    }
 
    if (!delimited->open(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::open_composite_reader: failed to open '{}' because {}",
            filepath, delimited->get_last_error());
        return nullptr;
    }
 
    return delimited;
}
 
std::shared_ptr<Kakshya::CompositeContainer>
IOManager::load_composite(
    const std::string& filepath,
    std::optional<Kakshya::CompositeLayout> layout,
    size_t batch_size)
{
    auto reader = open_composite_reader(filepath, std::move(layout));
    if (!reader)
        return nullptr;
 
    auto container = reader->create_composite_container(batch_size);
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_composite: failed to read '{}' because {}",
            filepath, reader->get_last_error());
        return nullptr;
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "IOManager::load_composite: loaded '{}'",
        std::filesystem::path(filepath).filename().string());
 
    return container;
}
 
std::shared_ptr<CompositeWriter>
IOManager::open_composite_writer(
    const std::string& filepath,
    const Kakshya::CompositeLayout& layout)
{
    auto writer = std::make_shared<DelimitedTextWriter>();
    if (!writer->can_write(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::open_composite_writer: unsupported format '{}'", filepath);
        return nullptr;
    }
 
    if (!writer->open(filepath, layout)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::open_composite_writer: failed to open '{}' because {}",
            filepath, writer->get_last_error());
        return nullptr;
    }
 
    return writer;
}
 
bool IOManager::save_composite(
    const std::shared_ptr<Kakshya::CompositeContainer>& container,
    const std::string& filepath)
{
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::save_composite: null container");
        return false;
    }
 
    const auto& array = container->get_data();
    auto writer = open_composite_writer(filepath, array.layout());
    if (!writer)
        return false;
 
    const auto rows = array.slice(0, array.size());
    const bool written = rows && writer->write_rows(*rows);
    const std::string write_error = !rows
        ? "could not access the container's elements"
        : writer->get_last_error();
    const bool closed = writer->close();
 
    if (!written || !closed) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::save_composite: failed to write '{}' because {}",
            filepath, written ? writer->get_last_error() : write_error);
        return false;
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "IOManager::save_composite: wrote '{}'",
        std::filesystem::path(filepath).filename().string());
 
    return true;
}
 
std::vector<std::shared_ptr<Buffers::MeshBuffer>>
IOManager::load_mesh(const std::string& filepath, TextureResolver resolver)
{
    auto reader = std::make_shared<ModelReader>();
 
    if (!reader->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_mesh: unsupported format '{}'", filepath);
        return {};
    }
 
    if (!reader->open(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_mesh: failed to open '{}' — {}",
            filepath, reader->get_last_error());
        return {};
    }
 
    if (!resolver)
        resolver = Detail::make_default_resolver(filepath);
 
    auto buffers = reader->create_mesh_buffers(resolver);
    reader->close();
 
    if (buffers.empty()) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_mesh: no meshes in '{}'", filepath);
        return {};
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "IOManager::load_mesh: {} mesh(es) from '{}'",
        buffers.size(),
        std::filesystem::path(filepath).filename().string());
 
    return buffers;
}
 
std::shared_ptr<Nodes::Network::MeshNetwork>
IOManager::load_mesh_network(const std::string& filepath, TextureResolver resolver)
{
    auto reader = std::make_shared<ModelReader>();
 
    if (!reader->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_mesh_network: unsupported format '{}'", filepath);
        return nullptr;
    }
 
    if (!reader->open(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_mesh_network: failed to open '{}' — {}",
            filepath, reader->get_last_error());
        return nullptr;
    }
 
    if (!resolver)
        resolver = Detail::make_default_resolver(filepath);
 
    auto net = reader->create_mesh_network(resolver);
    reader->close();
 
    if (!net) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_mesh_network: no network from '{}'", filepath);
        return nullptr;
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "IOManager::load_mesh_network: {} slots from '{}'",
        net->slot_count(),
        std::filesystem::path(filepath).filename().string());
 
    return net;
}
 
void IOManager::track_save_task(std::future<bool> fut)
{
    m_save_tasks.submit(std::move(fut));
}
 
bool IOManager::save_mesh(
    const std::shared_ptr<Buffers::MeshBuffer>& mesh_buffer,
    const std::string& filepath,
    const IO::ModelWriteOptions& options)
{
    track_save_task(std::async(std::launch::async,
        [mesh_buffer, filepath, options]() -> bool {
            return IO::save_mesh(mesh_buffer, filepath, options);
        }));
 
    return true;
}
 
bool IOManager::save_mesh(
    const std::vector<Kakshya::MeshData>& meshes,
    const std::string& filepath,
    const IO::ModelWriteOptions& options)
{
    track_save_task(std::async(std::launch::async,
        [meshes, filepath, options]() -> bool {
            return Detail::execute_mesh_write(filepath, meshes, options);
        }));
 
    return true;
}
 
bool IOManager::save_mesh(
    const std::shared_ptr<Nodes::Network::MeshNetwork>& network,
    const std::string& filepath,
    const IO::ModelWriteOptions& options)
{
    track_save_task(std::async(std::launch::async,
        [network, filepath, options]() -> bool {
            return IO::save_mesh(network, filepath, options);
        }));
 
    return true;
}
 
bool IOManager::save_mesh(
    const std::shared_ptr<Buffers::ComputeMeshBuffer>& buffer,
    const std::string& filepath,
    const IO::ModelWriteOptions& options)
{
    if (!buffer) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "save_mesh: null buffer");
        return false;
    }
 
    track_save_task(std::async(std::launch::async,
        [buffer, filepath, options]() -> bool {
            return IO::save_mesh(buffer, filepath, options);
        }));
 
    return true;
}
 
bool IOManager::save_mesh_snapshot(
    const std::shared_ptr<Buffers::ComputeMeshBuffer>& buffer,
    const std::string& path_pattern,
    const IO::ModelWriteOptions& options)
{
    if (!buffer) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "save_mesh_snapshot: null buffer");
        return false;
    }
 
    track_save_task(std::async(std::launch::async,
        [buffer, path_pattern, options]() -> bool {
            return Detail::execute_mesh_snapshot(buffer, path_pattern, options);
        }));
 
    return true;
}
 
void IOManager::configure_frame_processor(
    const std::shared_ptr<Kakshya::VideoFileContainer>& container) const
{
    Detail::configure_video_container(container, m_frame_rate);
}
 
void IOManager::configure_audio_processor(
    const std::shared_ptr<Kakshya::SoundFileContainer>& container) const
{
    Detail::configure_audio_container(container, m_stream_info.buffer_size);
}
 
std::shared_ptr<Buffers::VideoContainerBuffer>
IOManager::hook_video_container_to_buffer(
    const std::shared_ptr<Kakshya::VideoStreamContainer>& container)
{
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "hook_video_container_to_buffer: null container");
        return nullptr;
    }
 
    if (const auto dynamic = std::dynamic_pointer_cast<Kakshya::DynamicVideoStream>(container);
        dynamic && !dynamic->get_default_processor()) {
        dynamic->create_default_processor();
    }
 
    auto stream_container = std::dynamic_pointer_cast<Kakshya::StreamContainer>(container);
 
    if (!stream_container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "hook_video_container_to_buffer: container is not a VideoStreamContainer");
        return nullptr;
    }
 
    auto video_buffer = Detail::create_video_container_buffer(m_buffer_manager, stream_container);
 
    {
        std::unique_lock lock(m_buffers_mutex);
        m_video_buffers[container] = video_buffer;
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::BufferManagement,
        "Hooked VideoFileContainer to VideoContainerBuffer ({}x{})",
        video_buffer->get_width(), video_buffer->get_height());
 
    return video_buffer;
}
 
std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>>
IOManager::hook_audio_container_to_buffers(
    const std::shared_ptr<Kakshya::SoundFileContainer>& container)
{
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "hook_audio_container_to_buffers: null container");
        return {};
    }
 
    MF_TRACE(
        Journal::Component::API,
        Journal::Context::BufferManagement,
        "Setting up audio playback for {} channels...",
        container->get_num_channels());
 
    auto created_buffers = Detail::create_audio_container_buffers(m_buffer_manager, container);
 
    for (size_t channel = 0; channel < created_buffers.size(); ++channel) {
        MF_INFO(
            Journal::Component::API,
            Journal::Context::BufferManagement,
            "✓ Created buffer for channel {}",
            channel);
    }
 
    m_audio_buffers[container] = created_buffers;
 
    return created_buffers;
}
 
std::shared_ptr<Buffers::VideoContainerBuffer>
IOManager::hook_camera_to_buffer(
    const std::shared_ptr<Kakshya::CameraContainer>& container)
{
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "hook_camera_to_buffer: null container");
        return nullptr;
    }
 
    auto stream_container = std::dynamic_pointer_cast<Kakshya::StreamContainer>(container);
    if (!stream_container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "hook_camera_to_buffer: container is not a StreamContainer");
        return nullptr;
    }
 
    auto video_buffer = Detail::create_video_container_buffer(m_buffer_manager, stream_container);
 
    if (!video_buffer) {
        MF_ERROR(Journal::Component::API, Journal::Context::BufferManagement,
            "hook_camera_to_buffer: failed to create VideoContainerBuffer");
        return nullptr;
    }
 
    {
        std::unique_lock lock(m_camera_mutex);
        m_camera_buffers[container] = video_buffer;
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::BufferManagement,
        "Hooked CameraContainer to VideoContainerBuffer ({}x{})",
        video_buffer->get_width(), video_buffer->get_height());
 
    return video_buffer;
}
 
std::shared_ptr<Buffers::VideoContainerBuffer>
IOManager::get_video_buffer(
    const std::shared_ptr<Kakshya::VideoStreamContainer>& container) const
{
    std::shared_lock lock(m_buffers_mutex);
    auto it = m_video_buffers.find(container);
    return it != m_video_buffers.end() ? it->second : nullptr;
}
 
std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>>
IOManager::get_audio_buffers(
    const std::shared_ptr<Kakshya::SoundFileContainer>& container) const
{
    std::shared_lock lock(m_buffers_mutex);
    auto it = m_audio_buffers.find(container);
    return it != m_audio_buffers.end() ? it->second : std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>> {};
}
 
std::shared_ptr<Kakshya::SoundFileContainer>
IOManager::get_extracted_audio(const std::shared_ptr<Kakshya::VideoFileContainer>& container) const
{
    std::shared_lock lock(m_buffers_mutex);
    auto it = m_extracted_audio.find(container);
    return it != m_extracted_audio.end() ? it->second : nullptr;
}
 
std::shared_ptr<Buffers::VideoContainerBuffer>
IOManager::get_camera_buffer(
    const std::shared_ptr<Kakshya::CameraContainer>& container) const
{
    std::shared_lock lock(m_camera_mutex);
    auto it = m_camera_buffers.find(container);
    return it != m_camera_buffers.end() ? it->second : nullptr;
}
 
bool IOManager::save_image(
    const std::shared_ptr<Core::VKImage>& image,
    const std::string& filepath,
    const IO::ImageWriteOptions& options)
{
    if (!image) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "save_image: null image");
        return false;
    }
 
    track_save_task(std::async(std::launch::async,
        [image, filepath, options]() -> bool {
            auto data = IO::download_image(image);
            if (!data) {
                MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                    "save_image task: download failed for '{}'", filepath);
                return false;
            }
 
            return Detail::execute_image_write(filepath, *data, options);
        }));
 
    return true;
}
 
bool IOManager::save_image(
    const std::shared_ptr<Buffers::TextureBuffer>& buffer,
    const std::string& filepath,
    const IO::ImageWriteOptions& options)
{
    if (!buffer) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "save_image: null buffer");
        return false;
    }
    auto image = buffer->get_gpu_texture();
    if (!image) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "save_image: buffer has no GPU texture");
        return false;
    }
    return save_image(image, filepath, options);
}
 
bool IOManager::save_image(
    const std::shared_ptr<Buffers::TextBuffer>& buffer,
    const std::string& filepath,
    const IO::ImageWriteOptions& options)
{
    return save_image(
        std::static_pointer_cast<Buffers::TextureBuffer>(buffer),
        filepath,
        options);
}
 
bool IOManager::save_image(
    IO::ImageData data,
    const std::string& filepath,
    const IO::ImageWriteOptions& options)
{
    track_save_task(std::async(std::launch::async,
        [data = std::move(data),
            filepath,
            options]() -> bool {
            return Detail::execute_image_write(filepath, data, options);
        }));
 
    return true;
}
 
std::shared_ptr<Buffers::VolumeGridBuffer>
IOManager::load_volume(const std::string& filepath, const IO::VolumeReadOptions& options)
{
    IO::VolumeReader reader;
 
    if (!reader.can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_volume: unsupported format '{}'", filepath);
        return nullptr;
    }
 
    auto data = reader.load(filepath, options);
    if (!data) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_volume: failed to load '{}' — {}",
            filepath, reader.get_last_error());
        return nullptr;
    }
 
    auto buffer = Detail::create_volume_grid_buffer(m_buffer_manager, *data);
 
    if (!buffer) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "IOManager::load_volume: failed to construct or upload VolumeGridBuffer for '{}'", filepath);
        return nullptr;
    }
 
    m_loaded_volumes.push_back(buffer);
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "IOManager::load_volume: {} field(s) from '{}'",
        data->fields.size(),
        std::filesystem::path(filepath).filename().string());
 
    return buffer;
}
 
bool IOManager::save_volume(
    Kakshya::VolumeData data,
    const std::string& filepath,
    const IO::VolumeWriteOptions& options)
{
    track_save_task(std::async(std::launch::async,
        [data = std::move(data),
            filepath,
            options]() -> bool {
            return Detail::execute_volume_write(filepath, data, options);
        }));
 
    return true;
}
 
bool IOManager::save_volume(
    const std::shared_ptr<Buffers::VolumeGridBuffer>& volume,
    const std::string& filepath,
    const IO::VolumeWriteOptions& options,
    const std::vector<std::string>& field_names)
{
    if (!volume) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "save_volume: null volume");
        return false;
    }
 
    track_save_task(std::async(std::launch::async,
        [volume, filepath, options, field_names]() -> bool {
            auto data = IO::download_volume(volume, field_names);
            if (!data) {
                MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                    "save_volume task: download failed for '{}'", filepath);
                return false;
            }
 
            return Detail::execute_volume_write(filepath, *data, options);
        }));
 
    return true;
}
 
uint32_t IOManager::capture_volume(
    const std::shared_ptr<Buffers::VolumeGridBuffer>& volume,
    const std::string& path_pattern,
    const std::vector<std::string>& field_names,
    const IO::VolumeWriteOptions& options,
    uint32_t max_frames,
    uint64_t frame_interval)
{
    if (!volume) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_volume: null volume");
        return 0;
    }
 
    if (!m_scheduler) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_volume: TaskScheduler unavailable");
        return 0;
    }
 
    auto capture = Detail::create_volume_capture(
        *m_scheduler, volume, path_pattern, field_names, options,
        [this](Kakshya::VolumeData&& data,
            const std::string& path,
            const IO::VolumeWriteOptions& opts) {
            return save_volume(std::move(data), path, opts);
        },
        max_frames, frame_interval);
 
    const uint32_t id = m_next_volume_capture_id.fetch_add(1, std::memory_order_relaxed);
 
    std::lock_guard lock(m_volume_captures_mutex);
    m_volume_captures.emplace(id, std::move(capture));
    return id;
}
 
void IOManager::stop_volume_capture(uint32_t capture_id)
{
    std::unique_ptr<IO::VolumeCapture> capture;
    {
        std::lock_guard lock(m_volume_captures_mutex);
        auto it = m_volume_captures.find(capture_id);
        if (it == m_volume_captures.end()) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "stop_volume_capture: unknown capture_id={}", capture_id);
            return;
        }
        capture = std::move(it->second);
        m_volume_captures.erase(it);
    }
}
 
std::vector<uint32_t> IOManager::get_volume_capture_ids() const
{
    std::lock_guard lock(m_volume_captures_mutex);
    std::vector<uint32_t> ids;
    ids.reserve(m_volume_captures.size());
    for (const auto& [id, _] : m_volume_captures)
        ids.push_back(id);
    return ids;
}
 
uint32_t IOManager::capture_spatial(
    const std::string& filepath,
    std::vector<IO::SpatialCaptureSource> sources,
    uint32_t max_frames,
    uint64_t frame_interval)
{
    if (sources.empty()) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_spatial: no sources");
        return 0;
    }
 
    if (!m_scheduler) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "capture_spatial: TaskScheduler unavailable");
        return 0;
    }
 
    std::shared_ptr<IO::SpatialCache> cache;
    {
        std::lock_guard lock(m_spatial_captures_mutex);
        auto it = m_spatial_caches.find(filepath);
        if (it != m_spatial_caches.end()) {
            cache = it->second;
        } else {
            auto new_cache = std::make_shared<IO::SpatialCache>();
            if (!new_cache->open(filepath)) {
                MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                    "capture_spatial: failed to open '{}': {}", filepath, new_cache->get_last_error());
                return 0;
            }
            cache = new_cache;
            m_spatial_caches.emplace(filepath, cache);
        }
        ++m_spatial_cache_refcounts[filepath];
    }
 
    auto capture = Detail::create_spatial_capture(*m_scheduler, cache, std::move(sources), max_frames, frame_interval);
 
    const uint32_t id = m_next_spatial_capture_id.fetch_add(1, std::memory_order_relaxed);
 
    std::lock_guard lock(m_spatial_captures_mutex);
    m_spatial_captures.emplace(id, SpatialCaptureEntry { .capture = std::move(capture), .filepath = filepath });
    return id;
}
 
void IOManager::stop_spatial_capture(uint32_t capture_id)
{
    std::unique_ptr<IO::SpatialCapture> capture;
    std::shared_ptr<IO::SpatialCache> cache_to_close;
    {
        std::lock_guard lock(m_spatial_captures_mutex);
        auto it = m_spatial_captures.find(capture_id);
        if (it == m_spatial_captures.end()) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "stop_spatial_capture: unknown capture_id={}", capture_id);
            return;
        }
        capture = std::move(it->second.capture);
        const std::string filepath = std::move(it->second.filepath);
        m_spatial_captures.erase(it);
 
        auto ref_it = m_spatial_cache_refcounts.find(filepath);
        if (ref_it != m_spatial_cache_refcounts.end() && --ref_it->second <= 0) {
            m_spatial_cache_refcounts.erase(ref_it);
            auto cache_it = m_spatial_caches.find(filepath);
            if (cache_it != m_spatial_caches.end()) {
                cache_to_close = cache_it->second;
                m_spatial_caches.erase(cache_it);
            }
        }
    }
 
    capture.reset();
    if (cache_to_close) {
        cache_to_close->close();
    }
}
 
std::vector<uint32_t> IOManager::get_spatial_capture_ids() const
{
    std::lock_guard lock(m_spatial_captures_mutex);
    std::vector<uint32_t> ids;
    ids.reserve(m_spatial_captures.size());
    for (const auto& [id, _] : m_spatial_captures)
        ids.push_back(id);
    return ids;
}
 
bool IOManager::save_spatial_snapshot(
    std::vector<IO::SpatialCaptureSource> sources,
    const std::string& path_pattern)
{
    track_save_task(std::async(std::launch::async,
        [sources = std::move(sources), path_pattern]() -> bool {
            return Detail::execute_spatial_snapshot(path_pattern, sources);
        }));
    return true;
}
 
void IOManager::wait_for_pending_saves()
{
    m_save_tasks.drain();
}
 
std::vector<uint64_t> IOManager::get_video_reader_ids() const
{
    std::shared_lock lock(m_readers_mutex);
    std::vector<uint64_t> ids;
    ids.reserve(m_video_readers.size());
    for (const auto& [id, _] : m_video_readers)
        ids.push_back(id);
    return ids;
}
 
std::shared_ptr<VideoFileReader> IOManager::get_video_reader(uint64_t id) const
{
    std::shared_lock lock(m_readers_mutex);
    auto it = m_video_readers.find(id);
    return it != m_video_readers.end() ? it->second : nullptr;
}
 
std::vector<uint64_t> IOManager::get_camera_reader_ids() const
{
    std::shared_lock lock(m_camera_mutex);
    std::vector<uint64_t> ids;
    ids.reserve(m_camera_readers.size());
    for (const auto& [id, _] : m_camera_readers)
        ids.push_back(id);
    return ids;
}
 
std::shared_ptr<CameraSource> IOManager::get_camera_reader(uint64_t id) const
{
    std::shared_lock lock(m_camera_mutex);
    auto it = m_camera_readers.find(id);
    return it != m_camera_readers.end() ? it->second : nullptr;
}
 
} // namespace MayaFlux::IO