pull_frame()

bool MayaFlux::IO::CameraReader::pull_frame

(

const std::shared_ptr< Kakshya::CameraContainer > &

container

)

Decode one frame from the device into the container's m_data[0].

Pumps packets until one decoded frame is available, converts to RGBA via swscale into container->mutable_frame_ptr(), then calls container->mark_ready_for_processing(true). Returns false on EAGAIN (no frame yet) — not an error, just no data available this cycle.

The caller is responsible for invoking this once per graphics cycle, before the container's process_default() is triggered by downstream consumers. Typical integration: register as a graphics pre_process_hook or call explicitly before buffer processing.

Parameters

container

Target CameraContainer.

Returns

True if a new frame was written, false if no frame was available.

Definition at line 143 of file CameraReader.cpp.

{
    if (!container)
        return false;
 
    std::shared_lock lock(m_ctx_mutex);
    if (!m_video->is_codec_valid())
        return false;
 
    uint8_t* dest = container->mutable_frame_ptr();
    if (!dest)
        return false;
 
    AVPacket* pkt = av_packet_alloc();
    if (!pkt)
        return false;
 
    AVFrame* frame = av_frame_alloc();
    if (!frame) {
        av_packet_free(&pkt);
        return false;
    }
 
    bool got_frame = false;
 
    while (!got_frame) {
        int ret = av_read_frame(m_demux->format_context, pkt);
        if (ret < 0)
            break;
 
        if (pkt->stream_index != m_video->stream_index) {
            av_packet_unref(pkt);
            continue;
        }
 
        ret = avcodec_send_packet(m_video->codec_context, pkt);
        av_packet_unref(pkt);
 
        if (ret < 0 && ret != AVERROR(EAGAIN))
            break;
 
        ret = avcodec_receive_frame(m_video->codec_context, frame);
        if (ret == AVERROR(EAGAIN))
            continue;
        if (ret < 0)
            break;
 
        if (!m_scaler_ready) {
            if (!m_video->rebuild_scaler_from_frame(
                    frame,
                    static_cast<uint32_t>(frame->width),
                    static_cast<uint32_t>(frame->height))) {
                MF_ERROR(Journal::Component::IO, Journal::Context::Runtime,
                    "CameraReader: scaler init failed: {}",
                    m_video->last_error());
                break;
            }
            const size_t buf_bytes = static_cast<size_t>(m_video->out_linesize) * m_video->out_height;
            m_sws_buf.assign(buf_bytes, 0);
            m_scaler_ready = true;
        }
 
        uint8_t* sws_dst[1] = { m_sws_buf.data() };
        int sws_stride[1] = { m_video->out_linesize };
 
        sws_scale(m_video->sws_context,
            frame->data, frame->linesize,
            0, static_cast<int>(m_video->height),
            sws_dst, sws_stride);
 
        const int packed_stride = static_cast<int>(m_video->out_width * m_video->out_bytes_per_pixel);
 
        if (m_video->out_linesize == packed_stride) {
            std::memcpy(dest, m_sws_buf.data(),
                static_cast<size_t>(packed_stride) * m_video->out_height);
        } else {
            for (uint32_t row = 0; row < m_video->out_height; ++row) {
                std::memcpy(
                    dest + static_cast<size_t>(row) * packed_stride,
                    m_sws_buf.data() + static_cast<size_t>(row) * m_video->out_linesize,
                    static_cast<size_t>(packed_stride));
            }
        }
 
        container->mark_ready_for_processing(true);
        got_frame = true;
    }
 
    av_frame_free(&frame);
    av_packet_free(&pkt);
 
    return got_frame;
}

References MayaFlux::Journal::IO, m_ctx_mutex, m_demux, m_scaler_ready, m_sws_buf, m_video, MF_ERROR, and MayaFlux::Journal::Runtime.

Referenced by decode_thread_func().

Here is the caller graph for this function: