worker_loop()

void MayaFlux::IO::VideoFileWriter::worker_loop ( const std::string &  filepath, uint32_t  width, uint32_t  height, double  frame_rate, AVPixelFormat  src_fmt, AVCodecID  codec_id  )

private

Definition at line 369 of file VideoFileWriter.cpp.

{
    FFmpegMuxContext mux;
    VideoEncodeContext enc;
 
    auto fail = [&](std::string msg) {
        set_error(std::move(msg));
        m_open.store(false, std::memory_order_release);
        m_close_promise.set_value(false);
    };
 
    if (!mux.open(filepath)) {
        fail(mux.last_error());
        return;
    }
    if (!enc.open(mux, width, height, frame_rate, src_fmt, codec_id)) {
        fail(enc.last_error());
        return;
    }
    if (!mux.write_header()) {
        fail(mux.last_error());
        return;
    }
 
    m_open.store(true, std::memory_order_release);
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "[VideoFileWriter] worker started: '{}' {}x{} @{:.3f}fps",
        filepath, width, height, frame_rate);
 
    while (true) {
        auto item_opt = m_queue->pop();
        if (!item_opt) {
            std::this_thread::sleep_for(std::chrono::microseconds(100));
            continue;
        }
 
        bool done = std::visit([&](auto& cmd) -> bool {
            using T = std::decay_t<decltype(cmd)>;
 
            if constexpr (std::is_same_v<T, RawFrame>) {
                if (!enc.encode_frame(cmd.pixels.data(), cmd.pixels.size(),
                        cmd.width, cmd.height, mux)) {
                    set_error(enc.last_error());
                    MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                        "[VideoFileWriter] encode_frame failed: {}", enc.last_error());
                }
                return false;
            }
 
            if constexpr (std::is_same_v<T, DownloadCmd>) {
                const auto img_fmt = cmd.buffer->get_format();
                const AVPixelFormat av_fmt = image_format_to_avpixfmt(img_fmt);
                if (av_fmt == AV_PIX_FMT_NONE) {
                    MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                        "[VideoFileWriter] DownloadCmd: unsupported ImageFormat {}",
                        static_cast<int>(img_fmt));
                    return false;
                }
 
                const auto& cpu = cmd.buffer->get_pixel_data();
                if (!cpu.empty()) {
                    if (!enc.encode_frame(cpu.data(), cpu.size(),
                            cmd.buffer->get_width(), cmd.buffer->get_height(), mux)) {
                        set_error(enc.last_error());
                        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                            "[VideoFileWriter] encode_frame (cpu) failed: {}", enc.last_error());
                    }
                    return false;
                }
 
                auto tex = cmd.buffer->get_texture();
                if (!tex) {
                    MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                        "[VideoFileWriter] DownloadCmd: no CPU pixels and no GPU texture");
                    return false;
                }
 
                using Portal::Graphics::TextureLoom;
                const size_t mip0_bytes = static_cast<size_t>(tex->get_width())
                    * tex->get_height()
                    * TextureLoom::get_bytes_per_pixel(img_fmt);
 
                if (mip0_bytes == 0)
                    return false;
 
                std::vector<uint8_t> pixels(mip0_bytes);
 
                if (!m_staging_buffer) {
                    m_staging_buffer = Buffers::create_image_staging_buffer(mip0_bytes);
                }
 
                TextureLoom::instance().download_data(tex, pixels.data(), mip0_bytes, m_staging_buffer, true);
 
                if (!enc.encode_frame(pixels.data(), pixels.size(),
                        tex->get_width(), tex->get_height(), mux)) {
                    set_error(enc.last_error());
                    MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                        "[VideoFileWriter] encode_frame (gpu) failed: {}", enc.last_error());
                }
                return false;
            }
 
            return static_cast<bool>(std::is_same_v<T, CloseCmd>);
        },
            *item_opt);
 
        if (done)
            break;
    }
 
    bool ok = enc.drain(mux);
    if (!ok) {
        set_error(enc.last_error());
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "[VideoFileWriter] drain failed: {}", enc.last_error());
    }
 
    mux.close();
    m_open.store(false, std::memory_order_release);
    m_close_promise.set_value(ok);
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "[VideoFileWriter] worker finished: '{}' status={}",
        filepath, ok ? "ok" : "error");
}

References MayaFlux::IO::FFmpegMuxContext::close(), cmd, MayaFlux::Buffers::create_image_staging_buffer(), MayaFlux::IO::VideoEncodeContext::drain(), MayaFlux::IO::VideoEncodeContext::encode_frame(), MayaFlux::Journal::FileIO, height, MayaFlux::Journal::IO, MayaFlux::IO::FFmpegMuxContext::last_error(), MayaFlux::IO::VideoEncodeContext::last_error(), m_close_promise, m_open, m_queue, m_staging_buffer, MF_ERROR, MF_INFO, MF_WARN, MayaFlux::IO::FFmpegMuxContext::open(), MayaFlux::IO::VideoEncodeContext::open(), pixels, set_error(), MayaFlux::IO::T, width, and MayaFlux::IO::FFmpegMuxContext::write_header().

Referenced by open().

Here is the call graph for this function:

Here is the caller graph for this function: