decode_batch()

uint64_t MayaFlux::IO::VideoFileReader::decode_batch ( Kakshya::VideoFileContainer &  vc, uint64_t  batch_size  )

private

Decode up to batch_size frames starting at m_decode_head.

Pumps packets in a loop, draining multiple frames per packet batch. Returns the number of frames actually decoded.

Definition at line 385 of file VideoFileReader.cpp.

{
    std::shared_lock ctx_lock(m_context_mutex);
    if (!m_demux || !m_video || !m_video->is_valid())
        return 0;
 
    const size_t required = static_cast<size_t>(m_video->out_linesize) * m_video->out_height;
    if (m_sws_buf.size() < required)
        m_sws_buf.resize(required);
 
    const size_t frame_bytes = vc.get_frame_byte_size();
    const int packed_stride = static_cast<int>(
        m_video->out_width * m_video->out_bytes_per_pixel);
 
    uint64_t decoded = 0;
 
    AVPacket* pkt = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
    if (!pkt || !frame) {
        av_packet_free(&pkt);
        av_frame_free(&frame);
        return 0;
    }
 
    uint8_t* sws_dst[1] = { m_sws_buf.data() };
    int sws_stride[1] = { m_video->out_linesize };
 
    auto write_frame_to_ring = [&]() -> bool {
        uint64_t idx = m_decode_head.load();
        if (idx >= vc.get_total_source_frames())
            return false;
 
        uint8_t* dest = vc.mutable_slot_ptr(idx);
        if (!dest)
            return false;
 
        sws_scale(m_video->sws_context,
            frame->data, frame->linesize,
            0, static_cast<int>(m_video->height),
            sws_dst, sws_stride);
 
        if (m_video->out_linesize == packed_stride) {
            std::memcpy(dest, m_sws_buf.data(), frame_bytes);
        } 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));
            }
        }
 
        vc.commit_frame(idx);
        m_decode_head.fetch_add(1);
        ++decoded;
 
        av_frame_unref(frame);
        return true;
    };
 
    while (decoded < batch_size) {
        int ret = av_read_frame(m_demux->format_context, pkt);
 
        if (ret < 0) {
            if (ret == AVERROR_EOF) {
                avcodec_send_packet(m_video->codec_context, nullptr);
            } else {
                break;
            }
        } else if (pkt->stream_index != m_video->stream_index) {
            av_packet_unref(pkt);
            continue;
        } else {
            ret = avcodec_send_packet(m_video->codec_context, pkt);
            av_packet_unref(pkt);
            if (ret < 0 && ret != AVERROR(EAGAIN))
                continue;
        }
 
        while (decoded < batch_size) {
            ret = avcodec_receive_frame(m_video->codec_context, frame);
            if (ret == AVERROR(EAGAIN))
                break;
            if (ret == AVERROR_EOF)
                goto done;
            if (ret < 0) {
                av_frame_unref(frame);
                break;
            }
 
            if (!write_frame_to_ring())
                goto done;
        }
 
        if (ret == AVERROR_EOF)
            break;
    }
 
done:
    av_packet_free(&pkt);
    av_frame_free(&frame);
    return decoded;
}

References MayaFlux::Kakshya::VideoStreamContainer::commit_frame(), MayaFlux::Kakshya::VideoStreamContainer::get_frame_byte_size(), MayaFlux::Kakshya::VideoStreamContainer::get_total_source_frames(), m_context_mutex, m_decode_head, m_demux, m_sws_buf, m_video, and MayaFlux::Kakshya::VideoStreamContainer::mutable_slot_ptr().

Referenced by decode_thread_func(), load_into_container(), and seek().

Here is the call graph for this function:

Here is the caller graph for this function: