CpuVideoFramePool.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QByteArray>
#include <QtCore/QMutex>
#include <QtCore/QSize>
#include <QtMultimedia/QVideoFrame>
#include <QtMultimedia/QVideoFrameFormat>
#include <array>
#include <atomic>
#include <gst/gst.h>
#include <gst/video/video-info.h>
#include <memory>
 
class QAbstractVideoBuffer;
 
class CpuVideoFramePool
{
public:
    static CpuVideoFramePool& instance();
 
    QVideoFrame acquireFrame(const QVideoFrameFormat& format, const GstVideoInfo& info);
 
    static std::unique_ptr<QAbstractVideoBuffer> wrapZeroCopy(GstBuffer* buffer, const GstVideoInfo& info,
                                                              const QVideoFrameFormat& format);
 
    quint64 hitCount() const noexcept { return _hits.load(std::memory_order_relaxed); }
 
    quint64 missCount() const noexcept { return _misses.load(std::memory_order_relaxed); }
 
    struct PlaneLayout
    {
        int planeCount = 0;
        int bytesPerLine[4] = {};
        int height[4] = {};
        qsizetype planeOffset[4] = {};
        qsizetype byteSize = 0;
    };
 
    static PlaneLayout computeLayout(const GstVideoInfo& info);
 
    static QVideoFrame copyFromBuffer(GstBuffer* buffer, const GstVideoInfo& videoInfo,
                                      const QVideoFrameFormat& format);
 
    void releaseBacking(QSize size, QVideoFrameFormat::PixelFormat format, QByteArray&& backing);
 
private:
    CpuVideoFramePool() = default;
 
    QByteArray acquireBacking(const PlaneLayout& layout, QSize size, QVideoFrameFormat::PixelFormat format);
 
    static constexpr int kMaxPerSlot = 4;
    // Fixed-size slot array; round-robin eviction caps memory when resolution keeps changing.
    static constexpr int kMaxSlots = 8;
 
    struct Slot
    {
        QSize size;
        QVideoFrameFormat::PixelFormat format = QVideoFrameFormat::Format_Invalid;
        std::array<QByteArray, kMaxPerSlot> available;
        int availableCount = 0;
    };
 
    QMutex _mutex;
    std::array<Slot, kMaxSlots> _slots;
    int _evictCursor = 0;
    std::atomic<quint64> _hits{0};
    std::atomic<quint64> _misses{0};
};