pull_frame()

bool MayaFlux::IO::FFmpegCameraReader::pull_frame ( const std::shared_ptr< Kakshya::CameraContainer > &  container )

overridevirtual

Produce one frame into the container.

Writes pixel data into the container's frame buffer and marks it ready for processing. Returning false means no frame was available this cycle, which is not necessarily an error.

Parameters

container

Target CameraContainer.

Returns

True if a new frame was written.

Implements MayaFlux::IO::CameraSource.

Definition at line 231 of file FFmpegCameraReader.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,
                    "FFmpegCameraReader: 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: