record()

bool MayaFlux::IO::VideoFileWriter::record	(	const std::shared_ptr< Core::Window > &	window,
		const std::string &	filepath,
		double	frame_rate,
		AVCodecID	codec_id = AV_CODEC_ID_NONE
	)

Definition at line 100 of file VideoFileWriter.cpp.

{
    if (!window) {
        set_error("record: null window");
        return false;
    }
 
    auto* svc = Registry::BackendRegistry::instance()
                    .get_service<Registry::Service::DisplayService>();
    if (!svc || !svc->register_frame_observer) {
        set_error("record: DisplayService unavailable");
        return false;
    }
 
    if (m_observer_id.load(std::memory_order_acquire) != 0)
        stop_recording().get();
 
    m_capture_filepath = filepath;
    m_capture_frame_rate = frame_rate;
    m_capture_codec_id = codec_id;
    m_capture_window = window;
    m_capture_opened.store(false, std::memory_order_release);
 
    if (!window->is_capture_enabled()) {
        window->set_capture_enabled(true);
        m_capture_did_enable = true;
    }
 
    auto handle = std::static_pointer_cast<void>(window);
 
    uint32_t obs_id = svc->register_frame_observer(handle,
        [this](const std::shared_ptr<std::vector<uint8_t>>& buf,
            uint32_t w, uint32_t h, uint32_t vk_fmt) {
            if (!buf || buf->empty())
                return;
 
            if (!m_capture_opened.exchange(true, std::memory_order_acq_rel)) {
                const AVPixelFormat av_fmt = vk_format_to_avpixfmt(vk_fmt);
                if (!open(m_capture_filepath, w, h,
                        m_capture_frame_rate, av_fmt, m_capture_codec_id)) {
                    MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                        "[VideoFileWriter] record: failed to open encoder for "
                        "'{}': {}",
                        m_capture_filepath, last_error());
                    m_capture_opened.store(false, std::memory_order_release);
                    return;
                }
            }
 
            if (!m_open.load(std::memory_order_acquire))
                return;
 
            post(RawFrame {
                .pixels = std::vector<uint8_t>(buf->begin(), buf->end()),
                .width = w,
                .height = h });
        });
 
    if (obs_id == 0) {
        set_error("record: register_frame_observer returned 0 — "
                  "capture not yet active for this window");
        if (m_capture_did_enable) {
            window->set_capture_enabled(false);
            m_capture_did_enable = false;
        }
        m_capture_window.reset();
        return false;
    }
 
    m_observer_id.store(obs_id, std::memory_order_release);
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "[VideoFileWriter] record: observer {} registered for '{}' -> '{}'",
        obs_id, window->get_create_info().title, filepath);
 
    return true;
}

References MayaFlux::Journal::FileIO, MayaFlux::Registry::BackendRegistry::get_service(), h, MayaFlux::Registry::BackendRegistry::instance(), MayaFlux::Journal::IO, last_error(), m_capture_codec_id, m_capture_did_enable, m_capture_filepath, m_capture_frame_rate, m_capture_opened, m_capture_window, m_observer_id, m_open, MF_ERROR, MF_INFO, open(), MayaFlux::IO::VideoFileWriter::RawFrame::pixels, post(), set_error(), and stop_recording().

Here is the call graph for this function: