Depot.cpp

Go to the documentation of this file.

#include "Depot.hpp"
#include "MayaFlux/API/Config.hpp"
 
#include "MayaFlux/API/Core.hpp"
#include "MayaFlux/Core/Engine.hpp"
 
#include "MayaFlux/IO/Camera/FFmpegCameraReader.hpp"
#include "MayaFlux/IO/IOManager.hpp"
 
#include "MayaFlux/Buffers/Container/SoundContainerBuffer.hpp"
#include "MayaFlux/Kakshya/Source/CameraContainer.hpp"
#include "MayaFlux/Kakshya/Source/SoundFileContainer.hpp"
#include "MayaFlux/Kakshya/Source/VideoFileContainer.hpp"
#include "MayaFlux/Kakshya/Source/SoundStreamContainer.hpp"
 
#include "MayaFlux/Buffers/Geometry/MeshBuffer.hpp"
#include "MayaFlux/Buffers/State/VolumeGridBuffer.hpp"
 
#include "MayaFlux/Nodes/Network/MeshNetwork.hpp"
#include "MayaFlux/Transitive/Parallel/Dispatch.hpp"
 
#include "MayaFlux/Portal/Forma/Primitives/Picker.hpp"
#include "MayaFlux/Portal/System/Dialog/Chooser.hpp"
#include "MayaFlux/Portal/System/System.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
namespace fs = std::filesystem;
 
namespace MayaFlux {
 
namespace {
 
    bool require_portal(const char* caller)
    {
        if (!Portal::System::is_initialized()) {
            MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
                "{}: Portal::System not initialized", caller);
            return false;
        }
        return true;
    }
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_audio_open_filters {
        { .name = "Audio", .extensions = { "wav", "aiff", "aif", "flac", "ogg", "mp3", "m4a", "wma" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_audio_save_filters {
        { .name = "Audio", .extensions = { "wav", "flac", "ogg", "mp3" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_video_filters {
        { .name = "Video", .extensions = { "mp4", "mkv", "mov", "webm", "avi" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_image_filters {
        { .name = "Image", .extensions = { "png", "jpg", "jpeg", "bmp", "tga", "psd", "gif", "hdr", "pic", "pnm", "exr" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_composite_filters {
        { .name = "Composite data", .extensions = { "csv", "tsv" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_mesh_filters {
        { .name = "3D Model", .extensions = { "glb", "gltf", "fbx", "obj", "ply", "stl", "dae" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_image_save_filters {
        { .name = "Image", .extensions = { "png", "jpg", "jpeg", "bmp", "tga", "exr", "hdr" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_mesh_save_filters {
        { .name = "3D Model", .extensions = { "gltf", "glb", "obj", "fbx", "ply", "stl", "dae", "3ds", "x3d" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_volume_filters {
        { .name = "Volume", .extensions = { "vdb" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    const std::vector<Portal::System::Dialog::ChooserFilter> k_spatial_filters {
        { .name = "Alembic", .extensions = { "abc" } },
        { .name = "All Files", .extensions = { "*" } }
    };
 
    bool check_extension(const fs::path& filepath, const Portal::System::Dialog::ChooserFilter& filter)
    {
        if (!fs::exists(filepath) || !fs::is_regular_file(filepath))
            return false;
 
        auto ext = filepath.extension().string();
        if (ext.empty())
            return false;
 
        std::ranges::transform(ext, ext.begin(), [](unsigned char c) { return std::tolower(c); });
        const std::string_view bare { ext.data() + 1, ext.size() - 1 };
 
        return std::ranges::any_of(filter.extensions,
            [&](const std::string& e) { return e == bare; });
    }
 
} // namespace
 
// ---------------------------------------------------------------------------
 
std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>> prepare_audio_buffers(
    const std::shared_ptr<Kakshya::SoundFileContainer>& container)
{
    if (!container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "prepare_audio_buffers failed: null container");
        return {};
    }
 
    uint32_t num_channels = container->get_num_channels();
    std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>> created_buffers;
 
    for (uint32_t ch = 0; ch < num_channels; ++ch) {
        auto buf = std::make_shared<Buffers::SoundContainerBuffer>(
            ch, Config::get_buffer_size(), container, ch);
        buf->initialize();
        created_buffers.push_back(std::move(buf));
    }
 
    return created_buffers;
}
 
bool is_image(const fs::path& filepath)
{
    return check_extension(filepath, k_image_filters[0]);
}
 
bool is_audio(const fs::path& filepath)
{
    return check_extension(filepath, k_audio_open_filters[0]);
}
 
bool is_composite(const fs::path& filepath)
{
    return check_extension(filepath, k_composite_filters[0]);
}
 
std::shared_ptr<Buffers::VideoContainerBuffer> get_associated_buffer(
    const std::shared_ptr<Kakshya::VideoStreamContainer>& container)
{
    const auto io = get_io_manager();
    if (!io || !container) {
        return nullptr;
    }
 
    if (const auto camera = std::dynamic_pointer_cast<Kakshya::CameraContainer>(container)) {
        return io->get_camera_buffer(camera);
    }
 
    return io->get_video_buffer(container);
}
 
std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>> get_associated_buffers(
    const std::shared_ptr<Kakshya::SoundFileContainer>& container)
{
    const auto io = get_io_manager();
    if (!io || !container) {
        return {};
    }
 
    return io->get_audio_buffers(container);
}
 
std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>> get_associated_buffers(
    const std::shared_ptr<Kakshya::VideoFileContainer>& container)
{
    const auto io = get_io_manager();
    if (!io || !container) {
        return {};
    }
 
    const auto audio = io->get_extracted_audio(container);
    return audio ? io->get_audio_buffers(audio) : std::vector<std::shared_ptr<Buffers::SoundContainerBuffer>> {};
}
 
// ---------------------------------------------------------------------------
// Dialog-backed load
// ---------------------------------------------------------------------------
 
std::shared_ptr<Kakshya::SoundFileContainer> choose_audio()
{
    if (!require_portal("choose_audio"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Kakshya::SoundFileContainer>>(
        [](const fs::path& p) { return get_io_manager()->load_audio(p.string()); },
        [](Core::SystemDialogError) { },
        k_audio_open_filters);
}
 
std::shared_ptr<Kakshya::DynamicSoundStream> choose_audio_bounded(uint64_t max_frames, bool truncate)
{
    if (!require_portal("choose_audio_bounded"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Kakshya::DynamicSoundStream>>(
        [max_frames, truncate](const fs::path& p) {
            return get_io_manager()->load_audio_bounded(p.string(), max_frames, truncate);
        },
        [](Core::SystemDialogError) { },
        k_audio_open_filters);
}
 
IO::VideoLoadResult choose_video(const IO::VideoLoadConfig& config)
{
    if (!require_portal("choose_video"))
        return {};
 
    return Portal::System::Dialog::open_file<IO::VideoLoadResult>(
        [config](const fs::path& p) { return get_io_manager()->load_video(p.string(), config); },
        [](Core::SystemDialogError) { },
        k_video_filters);
}
 
std::shared_ptr<Buffers::TextureBuffer> choose_image(
    int desired_channels, std::optional<Kakshya::Region> region)
{
    if (!require_portal("choose_image"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Buffers::TextureBuffer>>(
        [desired_channels, region = std::move(region)](const fs::path& p) {
            return get_io_manager()->load_image(p.string(), desired_channels, region);
        },
        [](Core::SystemDialogError) { },
        k_image_filters);
}
 
std::shared_ptr<Kakshya::CompositeContainer> choose_composite()
{
    if (!require_portal("choose_composite"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Kakshya::CompositeContainer>>(
        [](const fs::path& p) { return get_io_manager()->load_composite(p.string()); },
        [](Core::SystemDialogError) { },
        k_composite_filters);
}
 
std::shared_ptr<Kakshya::CompositeContainer> choose_composite(
    const Kakshya::CompositeLayout& layout, size_t batch_size)
{
    if (!require_portal("choose_composite"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Kakshya::CompositeContainer>>(
        [&layout, batch_size](const fs::path& p) {
            return get_io_manager()->load_composite(p.string(), layout, batch_size);
        },
        [](Core::SystemDialogError) { },
        k_composite_filters);
}
 
std::vector<std::shared_ptr<Buffers::MeshBuffer>> choose_mesh()
{
    if (!require_portal("choose_mesh"))
        return {};
 
    return Portal::System::Dialog::open_file<std::vector<std::shared_ptr<Buffers::MeshBuffer>>>(
        [](const fs::path& p) { return get_io_manager()->load_mesh(p.string()); },
        [](Core::SystemDialogError) { },
        k_mesh_filters);
}
 
std::shared_ptr<Nodes::Network::MeshNetwork> choose_mesh_network(IO::TextureResolver resolver)
{
    if (!require_portal("choose_mesh_network"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Nodes::Network::MeshNetwork>>(
        [r = std::move(resolver)](const fs::path& p) mutable {
            return get_io_manager()->load_mesh_network(p.string(), std::move(r));
        },
        [](Core::SystemDialogError) { },
        k_mesh_filters);
}
 
std::shared_ptr<Buffers::VolumeGridBuffer> choose_volume()
{
    if (!require_portal("choose_volume"))
        return nullptr;
 
    return Portal::System::Dialog::open_file<std::shared_ptr<Buffers::VolumeGridBuffer>>(
        [](const fs::path& p) { return get_io_manager()->load_volume(p.string()); },
        [](Core::SystemDialogError) { },
        k_volume_filters);
}
 
std::shared_ptr<Kakshya::CameraContainer> choose_camera(bool choose_mode)
{
    auto promise = std::make_shared<std::promise<std::shared_ptr<Kakshya::CameraContainer>>>();
    auto future = promise->get_future();
 
    const IO::FFmpegCameraReader reader;
    auto configs = reader.enumerate_configs();
    if (configs.empty()) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "choose_camera: no cameras found");
        return nullptr;
    }
 
    Portal::Forma::pick("Choose a camera", std::move(configs),
        [](const IO::CameraConfig& config) {
            return config.display_name.empty() ? config.device_name : config.display_name;
        },
        [promise, choose_mode, modes = reader.preset_modes()](std::optional<IO::CameraConfig> camera) {
            if (!camera) {
                promise->set_value(nullptr);
                return;
            }
            if (!choose_mode) {
                promise->set_value(get_io_manager()->open_camera(*camera));
                return;
            }
            Portal::Forma::pick("Choose a mode", modes,
                [](const IO::CameraMode& mode) { return mode.label; },
                [promise, config = *camera](std::optional<IO::CameraMode> mode) mutable {
                    if (!mode) {
                        promise->set_value(nullptr);
                        return;
                    }
                    mode->apply(config);
                    promise->set_value(get_io_manager()->open_camera(config));
                });
        });
 
    return Parallel::await_future(std::move(future));
}
 
// ---------------------------------------------------------------------------
// Dialog-backed save
// ---------------------------------------------------------------------------
 
bool save_audio(
    const std::shared_ptr<Kakshya::SoundStreamContainer>& container,
    const std::string& suggested_name)
{
    if (!require_portal("save_audio"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_audio: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &container](const fs::path& p) {
            iom->write(container, p.string());
            return true;
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_audio_save_filters);
}
 
bool save_image(
    const std::shared_ptr<Buffers::TextureBuffer>& buffer,
    const std::string& suggested_name)
{
    if (!require_portal("save_image"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_image: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &buffer](const fs::path& p) {
            return iom->save_image(buffer, p.string(), IO::ImageWriteOptions {});
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_image_save_filters);
}
 
bool save_image(
    const std::shared_ptr<Buffers::TextureBuffer>& buffer,
    const std::string& suggested_name,
    const IO::ImageWriteOptions& options)
{
    if (!require_portal("save_image"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_image: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &buffer, &options](const fs::path& p) {
            return iom->save_image(buffer, p.string(), options);
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_image_save_filters);
}
 
bool save_composite(
    const std::shared_ptr<Kakshya::CompositeContainer>& container,
    const std::string& suggested_name)
{
    if (!require_portal("save_composite"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_composite: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &container](const fs::path& p) {
            return iom->save_composite(container, p.string());
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_composite_filters);
}
 
bool save_mesh(
    const std::shared_ptr<Buffers::MeshBuffer>& buffer,
    const std::string& suggested_name)
{
    return save_mesh(buffer, suggested_name, IO::ModelWriteOptions {});
}
 
bool save_mesh(
    const std::shared_ptr<Buffers::MeshBuffer>& buffer,
    const std::string& suggested_name,
    const IO::ModelWriteOptions& options)
{
    if (!require_portal("save_mesh"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_mesh: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &buffer, &options](const fs::path& p) {
            return iom->save_mesh(buffer, p.string(), options);
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_mesh_save_filters);
}
 
bool save_mesh(
    const std::shared_ptr<Nodes::Network::MeshNetwork>& network,
    const std::string& suggested_name)
{
    return save_mesh(network, suggested_name, IO::ModelWriteOptions {});
}
 
bool save_mesh(
    const std::shared_ptr<Nodes::Network::MeshNetwork>& network,
    const std::string& suggested_name,
    const IO::ModelWriteOptions& options)
{
    if (!require_portal("save_mesh"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_mesh: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &network, &options](const fs::path& p) {
            return iom->save_mesh(network, p.string(), options);
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_mesh_save_filters);
}
 
bool save_volume(
    const std::shared_ptr<Buffers::VolumeGridBuffer>& volume,
    const std::string& suggested_name)
{
    if (!require_portal("save_volume"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_volume: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &volume](const fs::path& p) {
            return iom->save_volume(volume, p.string(), IO::VolumeWriteOptions {});
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_volume_filters);
}
 
bool save_volume(
    const std::shared_ptr<Buffers::VolumeGridBuffer>& volume,
    const std::string& suggested_name,
    const IO::VolumeWriteOptions& options)
{
    if (!require_portal("save_volume"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_volume: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &volume, &options](const fs::path& p) {
            return iom->save_volume(volume, p.string(), options);
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_volume_filters);
}
 
bool save_spatial(
    std::vector<IO::SpatialCaptureSource> sources,
    const std::string& suggested_name)
{
    if (!require_portal("save_spatial"))
        return false;
 
    auto iom = get_io_manager();
    if (!iom) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "save_spatial: IOManager unavailable");
        return false;
    }
 
    return Portal::System::Dialog::save_file<bool>(
        [&iom, &sources](const fs::path& p) {
            return iom->save_spatial_snapshot(std::move(sources), p.string());
        },
        [](Core::SystemDialogError) { },
        suggested_name,
        k_spatial_filters);
}
 
// ---------------------------------------------------------------------------
 
std::shared_ptr<IO::IOManager> get_io_manager()
{
    if (is_engine_configured())
        return get_context().get_io_manager();
 
    MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
        "Attempted to access IOManager before engine initialization");
    return nullptr;
}
 
} // namespace MayaFlux