shutdown()

void MayaFlux::IO::IOManager::shutdown

(

)

Unregisters IOService and releases readers, writers, buffers and caches.

Calls stop() first. Call after the consuming threads have been joined and before the graphics backend is cleaned up, so objects whose destructors touch the backend are released while it is still alive. Idempotent.

Definition at line 172 of file IOManager.cpp.

{
    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");
}

References MayaFlux::Journal::Init, MayaFlux::Registry::BackendRegistry::instance(), MayaFlux::Journal::IO, m_audio_buffers, m_audio_readers, m_buffers_mutex, m_camera_buffers, m_camera_mutex, m_camera_readers, m_extracted_audio, m_image_readers, m_io_service, m_loaded_volumes, m_model_readers, m_readers_mutex, m_shutdown_done, m_spatial_cache_refcounts, m_spatial_caches, m_spatial_captures_mutex, m_video_buffers, m_video_captures_mutex, m_video_readers, m_video_writers, m_writers, m_writers_mutex, MF_INFO, stop(), MayaFlux::Registry::BackendRegistry::unregister_service(), and wait_for_pending_saves().

Referenced by ~IOManager().

Here is the call graph for this function:

Here is the caller graph for this function: